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/control-devel.h>
 451 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 452 #include <dali-toolkit/devel-api/controls/progress-bar/progress-bar.h>
 453 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 455 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 456 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 457 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 458 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 459
 460 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 461 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 462 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 463
 464 #include <dali-toolkit/devel-api/visuals/text-visual-properties.h>
 465
 466 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 467
 468 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 469
 470 #include <dali/devel-api/adaptor-framework/imf-manager.h>
 471
 472
 473 // add here SWIG version check
 474
 475 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 476 // disable Swig-dependent warnings
 477
 478 // 'identifier1' has C-linkage specified,
 479 // but returns UDT 'identifier2' which is incompatible with C
 480 #pragma warning(disable: 4190)
 481
 482 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 483 #pragma warning(disable: 4800)
 484
 485 // debug info too long etc etc
 486 #pragma warning(disable: 4786)
 487 #endif
 488
 489
 490 #include <stdexcept>
 491
 492
 493 #include <string>
 494
 495
 496 #include <vector>
 497 #include <algorithm>
 498 #include <stdexcept>
 499
 500
 501 #include <map>
 502 #include <algorithm>
 503 #include <stdexcept>
 504
 505
 506 #include <utility>
 507
 508
 509 typedef float floatp;
 510
 511 SWIGINTERN floatp *new_floatp(){
 512   return new float();
 513 }
 514 SWIGINTERN void delete_floatp(floatp *self){
 515   if (self) delete self;
 516 }
 517 SWIGINTERN void floatp_assign(floatp *self,float value){
 518   *self = value;
 519 }
 520 SWIGINTERN float floatp_value(floatp *self){
 521   return *self;
 522 }
 523 SWIGINTERN float *floatp_cast(floatp *self){
 524   return self;
 525 }
 526 SWIGINTERN floatp *floatp_frompointer(float *t){
 527   return (floatp *) t;
 528 }
 529
 530 typedef int intp;
 531
 532 SWIGINTERN intp *new_intp(){
 533   return new int();
 534 }
 535 SWIGINTERN void delete_intp(intp *self){
 536   if (self) delete self;
 537 }
 538 SWIGINTERN void intp_assign(intp *self,int value){
 539   *self = value;
 540 }
 541 SWIGINTERN int intp_value(intp *self){
 542   return *self;
 543 }
 544 SWIGINTERN int *intp_cast(intp *self){
 545   return self;
 546 }
 547 SWIGINTERN intp *intp_frompointer(int *t){
 548   return (intp *) t;
 549 }
 550
 551 typedef double doublep;
 552
 553 SWIGINTERN doublep *new_doublep(){
 554   return new double();
 555 }
 556 SWIGINTERN void delete_doublep(doublep *self){
 557   if (self) delete self;
 558 }
 559 SWIGINTERN void doublep_assign(doublep *self,double value){
 560   *self = value;
 561 }
 562 SWIGINTERN double doublep_value(doublep *self){
 563   return *self;
 564 }
 565 SWIGINTERN double *doublep_cast(doublep *self){
 566   return self;
 567 }
 568 SWIGINTERN doublep *doublep_frompointer(double *t){
 569   return (doublep *) t;
 570 }
 571
 572 typedef unsigned int uintp;
 573
 574 SWIGINTERN uintp *new_uintp(){
 575   return new unsigned int();
 576 }
 577 SWIGINTERN void delete_uintp(uintp *self){
 578   if (self) delete self;
 579 }
 580 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 581   *self = value;
 582 }
 583 SWIGINTERN unsigned int uintp_value(uintp *self){
 584   return *self;
 585 }
 586 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 587   return self;
 588 }
 589 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 590   return (uintp *) t;
 591 }
 592
 593 typedef unsigned short ushortp;
 594
 595 SWIGINTERN ushortp *new_ushortp(){
 596   return new unsigned short();
 597 }
 598 SWIGINTERN void delete_ushortp(ushortp *self){
 599   if (self) delete self;
 600 }
 601 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 602   *self = value;
 603 }
 604 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 605   return *self;
 606 }
 607 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 608   return self;
 609 }
 610 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 611   return (ushortp *) t;
 612 }
 613
 614 unsigned int int_to_uint(int x) {
 615    return (unsigned int) x;
 616 }
 617
 618
 619 using namespace Dali;
 620 using namespace Dali::Toolkit;
 621
 622 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self){
 623
 624      // C++ code. DALi uses Handle <-> Body design pattern.
 625      // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 626      // Handles in DALi can be converted into a boolean type
 627      // to check if the handle has a valid body attached to it.
 628      // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 629      if( *self )
 630      {
 631        return true;
 632      }
 633      else
 634      {
 635        return false;
 636      }
 637     }
 638 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs){
 639
 640      // C++ code. Check if two handles reference the same implemtion
 641      if( *self == rhs)
 642      {
 643        return true;
 644      }
 645      else
 646      {
 647        return false;
 648      }
 649     }
 650 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 651      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 652    }
 653 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){
 654      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 655    }
 656 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 657         std::vector< Dali::TouchPoint >* pv = 0;
 658         if (capacity >= 0) {
 659           pv = new std::vector< Dali::TouchPoint >();
 660           pv->reserve(capacity);
 661        } else {
 662           throw std::out_of_range("capacity");
 663        }
 664        return pv;
 665       }
 666 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 667         if (index>=0 && index<(int)self->size())
 668           return (*self)[index];
 669         else
 670           throw std::out_of_range("index");
 671       }
 672 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 673         if (index>=0 && index<(int)self->size())
 674           return (*self)[index];
 675         else
 676           throw std::out_of_range("index");
 677       }
 678 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 679         if (index>=0 && index<(int)self->size())
 680           (*self)[index] = val;
 681         else
 682           throw std::out_of_range("index");
 683       }
 684 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 685         self->insert(self->end(), values.begin(), values.end());
 686       }
 687 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 688         if (index < 0)
 689           throw std::out_of_range("index");
 690         if (count < 0)
 691           throw std::out_of_range("count");
 692         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 693           throw std::invalid_argument("invalid range");
 694         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 695       }
 696 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 697         if (index>=0 && index<(int)self->size()+1)
 698           self->insert(self->begin()+index, x);
 699         else
 700           throw std::out_of_range("index");
 701       }
 702 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 703         if (index>=0 && index<(int)self->size()+1)
 704           self->insert(self->begin()+index, values.begin(), values.end());
 705         else
 706           throw std::out_of_range("index");
 707       }
 708 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 709         if (index>=0 && index<(int)self->size())
 710           self->erase(self->begin() + index);
 711         else
 712           throw std::out_of_range("index");
 713       }
 714 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 715         if (index < 0)
 716           throw std::out_of_range("index");
 717         if (count < 0)
 718           throw std::out_of_range("count");
 719         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 720           throw std::invalid_argument("invalid range");
 721         self->erase(self->begin()+index, self->begin()+index+count);
 722       }
 723 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 724         if (count < 0)
 725           throw std::out_of_range("count");
 726         return new std::vector< Dali::TouchPoint >(count, value);
 727       }
 728 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 729         std::reverse(self->begin(), self->end());
 730       }
 731 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 732         if (index < 0)
 733           throw std::out_of_range("index");
 734         if (count < 0)
 735           throw std::out_of_range("count");
 736         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 737           throw std::invalid_argument("invalid range");
 738         std::reverse(self->begin()+index, self->begin()+index+count);
 739       }
 740 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 741         if (index < 0)
 742           throw std::out_of_range("index");
 743         if (index+values.size() > self->size())
 744           throw std::out_of_range("index");
 745         std::copy(values.begin(), values.end(), self->begin()+index);
 746       }
 747 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 748          return self->Empty();
 749       }
 750 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 751         return self->GetConnectionCount();
 752       }
 753 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 754           self->Connect( func );
 755       }
 756 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 757           self->Disconnect( func );
 758       }
 759 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 760           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 761 /*@SWIG@*/ self->Emit( arg );
 762       }
 763 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 764          return self->Empty();
 765       }
 766 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 767         return self->GetConnectionCount();
 768       }
 769 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 770           self->Connect( func );
 771       }
 772 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 773           self->Disconnect( func );
 774       }
 775 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 776           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 777 /*@SWIG@*/ self->Emit( arg );
 778       }
 779 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 780          return self->Empty();
 781       }
 782 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){
 783         return self->GetConnectionCount();
 784       }
 785 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 *)){
 786           self->Connect( func );
 787       }
 788 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 *)){
 789           self->Disconnect( func );
 790       }
 791 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){
 792           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 793 /*@SWIG@*/ self->Emit( arg );
 794       }
 795 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 796          return self->Empty();
 797       }
 798 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 799         return self->GetConnectionCount();
 800       }
 801 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 802           self->Connect( func );
 803       }
 804 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 805           self->Disconnect( func );
 806       }
 807 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 808           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 809 /*@SWIG@*/ self->Emit( arg );
 810       }
 811 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 812          return self->Empty();
 813       }
 814 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 815         return self->GetConnectionCount();
 816       }
 817 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 818           self->Connect( func );
 819       }
 820 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 821           self->Disconnect( func );
 822       }
 823 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 824           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 825 /*@SWIG@*/ self->Emit( arg );
 826       }
 827 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){
 828          return self->Empty();
 829       }
 830 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){
 831         return self->GetConnectionCount();
 832       }
 833 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 &)){
 834         self->Connect( func );
 835       }
 836 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 &)){
 837         self->Disconnect( func );
 838       }
 839 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){
 840         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 841 /*@SWIG@*/ self->Emit( arg1, arg2 );
 842       }
 843 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){
 844          return self->Empty();
 845       }
 846 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){
 847         return self->GetConnectionCount();
 848       }
 849 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 &)){
 850         self->Connect( func );
 851       }
 852 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 &)){
 853         self->Disconnect( func );
 854       }
 855 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){
 856         return self->Emit( arg1, arg2 );
 857       }
 858 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){
 859          return self->Empty();
 860       }
 861 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){
 862         return self->GetConnectionCount();
 863       }
 864 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 &)){
 865         self->Connect( func );
 866       }
 867 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 &)){
 868         self->Disconnect( func );
 869       }
 870 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){
 871         return self->Emit( arg1, arg2 );
 872       }
 873 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){
 874          return self->Empty();
 875       }
 876 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){
 877         return self->GetConnectionCount();
 878       }
 879 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 &)){
 880         self->Connect( func );
 881       }
 882 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 &)){
 883         self->Disconnect( func );
 884       }
 885 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){
 886         return self->Emit( arg1, arg2 );
 887       }
 888 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 889          return self->Empty();
 890       }
 891 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 892         return self->GetConnectionCount();
 893       }
 894 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 895           self->Connect( func );
 896       }
 897 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 898           self->Disconnect( func );
 899       }
 900 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 901           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 902 /*@SWIG@*/ self->Emit( arg );
 903       }
 904 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 905          return self->Empty();
 906       }
 907 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){
 908         return self->GetConnectionCount();
 909       }
 910 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 &)){
 911           self->Connect( func );
 912       }
 913 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 &)){
 914           self->Disconnect( func );
 915       }
 916 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){
 917           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 918 /*@SWIG@*/ self->Emit( arg );
 919       }
 920 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 921          return self->Empty();
 922       }
 923 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){
 924         return self->GetConnectionCount();
 925       }
 926 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 &)){
 927           self->Connect( func );
 928       }
 929 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 &)){
 930           self->Disconnect( func );
 931       }
 932 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){
 933           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 934 /*@SWIG@*/ self->Emit( arg );
 935       }
 936 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 937          return self->Empty();
 938       }
 939 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){
 940         return self->GetConnectionCount();
 941       }
 942 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 &)){
 943           self->Connect( func );
 944       }
 945 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 &)){
 946           self->Disconnect( func );
 947       }
 948 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){
 949           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 950 /*@SWIG@*/ self->Emit( arg );
 951       }
 952 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){
 953          return self->Empty();
 954       }
 955 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){
 956         return self->GetConnectionCount();
 957       }
 958 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 &)){
 959         self->Connect( func );
 960       }
 961 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 &)){
 962         self->Disconnect( func );
 963       }
 964 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){
 965         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 966 /*@SWIG@*/ self->Emit( arg1, arg2 );
 967       }
 968 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){
 969          return self->Empty();
 970       }
 971 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){
 972         return self->GetConnectionCount();
 973       }
 974 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 &)){
 975         self->Connect( func );
 976       }
 977 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 &)){
 978         self->Disconnect( func );
 979       }
 980 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){
 981         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 982 /*@SWIG@*/ self->Emit( arg1, arg2 );
 983       }
 984 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){
 985          return self->Empty();
 986       }
 987 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){
 988         return self->GetConnectionCount();
 989       }
 990 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 &)){
 991         self->Connect( func );
 992       }
 993 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 &)){
 994         self->Disconnect( func );
 995       }
 996 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){
 997         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 998 /*@SWIG@*/ self->Emit( arg1, arg2 );
 999       }
1000 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Animation &) > const *self){
1001          return self->Empty();
1002       }
1003 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Animation &) > const *self){
1004         return self->GetConnectionCount();
1005       }
1006 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
1007           self->Connect( func );
1008       }
1009 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
1010           self->Disconnect( func );
1011       }
1012 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Animation &) > *self,Dali::Animation &arg){
1013           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1014 /*@SWIG@*/ self->Emit( arg );
1015       }
1016 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1017          return self->Empty();
1018       }
1019 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1020         return self->GetConnectionCount();
1021       }
1022 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1023           self->Connect( func );
1024       }
1025 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1026           self->Disconnect( func );
1027       }
1028 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1029           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1030 /*@SWIG@*/ self->Emit( arg );
1031       }
1032 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1033          return self->Empty();
1034       }
1035 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1036         return self->GetConnectionCount();
1037       }
1038 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1039           return self->Connect( func );
1040       }
1041 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1042           self->Disconnect( func );
1043       }
1044 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,Dali::Actor arg1,bool arg2,Dali::DevelActor::VisibilityChange::Type arg3){
1045           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1046 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1047       }
1048
1049   // keep argcs and argv so they're always available to DALi
1050   int argC = 1;
1051   char **argV = NULL;
1052
1053 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Application &) > const *self){
1054          return self->Empty();
1055       }
1056 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &) > const *self){
1057         return self->GetConnectionCount();
1058       }
1059 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
1060           self->Connect( func );
1061       }
1062 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
1063           self->Disconnect( func );
1064       }
1065 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Application &) > *self,Dali::Application &arg){
1066           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1067 /*@SWIG@*/ self->Emit( arg );
1068       }
1069 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::Application &,void *) > const *self){
1070          return self->Empty();
1071       }
1072 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){
1073         return self->GetConnectionCount();
1074       }
1075 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 *)){
1076         self->Connect( func );
1077       }
1078 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 *)){
1079         self->Disconnect( func );
1080       }
1081 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){
1082         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1083 /*@SWIG@*/ self->Emit( arg1, arg2 );
1084       }
1085 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1086          return self->Empty();
1087       }
1088 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1089         return self->GetConnectionCount();
1090       }
1091 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1092           self->Connect( func );
1093       }
1094 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1095           self->Disconnect( func );
1096       }
1097 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1098           return self->Emit();
1099       }
1100 SWIGINTERN bool Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty(Dali::Signal< void (bool) > const *self){
1101          return self->Empty();
1102       }
1103 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (bool) > const *self){
1104         return self->GetConnectionCount();
1105       }
1106 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(Dali::Signal< void (bool) > *self,void (*func)(bool)){
1107           self->Connect( func );
1108       }
1109 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(Dali::Signal< void (bool) > *self,void (*func)(bool)){
1110           self->Disconnect( func );
1111       }
1112 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(Dali::Signal< void (bool) > *self,bool arg){
1113           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1114 /*@SWIG@*/ self->Emit( arg );
1115       }
1116 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1117         std::vector< unsigned int >* pv = 0;
1118         if (capacity >= 0) {
1119           pv = new std::vector< unsigned int >();
1120           pv->reserve(capacity);
1121        } else {
1122           throw std::out_of_range("capacity");
1123        }
1124        return pv;
1125       }
1126 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1127         if (index>=0 && index<(int)self->size())
1128           return (*self)[index];
1129         else
1130           throw std::out_of_range("index");
1131       }
1132 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1133         if (index>=0 && index<(int)self->size())
1134           return (*self)[index];
1135         else
1136           throw std::out_of_range("index");
1137       }
1138 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1139         if (index>=0 && index<(int)self->size())
1140           (*self)[index] = val;
1141         else
1142           throw std::out_of_range("index");
1143       }
1144 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1145         self->insert(self->end(), values.begin(), values.end());
1146       }
1147 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1148         if (index < 0)
1149           throw std::out_of_range("index");
1150         if (count < 0)
1151           throw std::out_of_range("count");
1152         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1153           throw std::invalid_argument("invalid range");
1154         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1155       }
1156 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1157         if (index>=0 && index<(int)self->size()+1)
1158           self->insert(self->begin()+index, x);
1159         else
1160           throw std::out_of_range("index");
1161       }
1162 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1163         if (index>=0 && index<(int)self->size()+1)
1164           self->insert(self->begin()+index, values.begin(), values.end());
1165         else
1166           throw std::out_of_range("index");
1167       }
1168 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1169         if (index>=0 && index<(int)self->size())
1170           self->erase(self->begin() + index);
1171         else
1172           throw std::out_of_range("index");
1173       }
1174 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(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         self->erase(self->begin()+index, self->begin()+index+count);
1182       }
1183 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1184         if (count < 0)
1185           throw std::out_of_range("count");
1186         return new std::vector< unsigned int >(count, value);
1187       }
1188 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1189         std::reverse(self->begin(), self->end());
1190       }
1191 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1192         if (index < 0)
1193           throw std::out_of_range("index");
1194         if (count < 0)
1195           throw std::out_of_range("count");
1196         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1197           throw std::invalid_argument("invalid range");
1198         std::reverse(self->begin()+index, self->begin()+index+count);
1199       }
1200 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1201         if (index < 0)
1202           throw std::out_of_range("index");
1203         if (index+values.size() > self->size())
1204           throw std::out_of_range("index");
1205         std::copy(values.begin(), values.end(), self->begin()+index);
1206       }
1207 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1208         return std::find(self->begin(), self->end(), value) != self->end();
1209       }
1210 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1211         int index = -1;
1212         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1213         if (it != self->end())
1214           index = (int)(it - self->begin());
1215         return index;
1216       }
1217 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1218         int index = -1;
1219         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1220         if (rit != self->rend())
1221           index = (int)(self->rend() - 1 - rit);
1222         return index;
1223       }
1224 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1225         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1226         if (it != self->end()) {
1227           self->erase(it);
1228           return true;
1229         }
1230         return false;
1231       }
1232 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){
1233         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1234         if (capacity >= 0) {
1235           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1236           pv->reserve(capacity);
1237        } else {
1238           throw std::out_of_range("capacity");
1239        }
1240        return pv;
1241       }
1242 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){
1243         if (index>=0 && index<(int)self->size())
1244           return (*self)[index];
1245         else
1246           throw std::out_of_range("index");
1247       }
1248 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){
1249         if (index>=0 && index<(int)self->size())
1250           return (*self)[index];
1251         else
1252           throw std::out_of_range("index");
1253       }
1254 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){
1255         if (index>=0 && index<(int)self->size())
1256           (*self)[index] = val;
1257         else
1258           throw std::out_of_range("index");
1259       }
1260 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){
1261         self->insert(self->end(), values.begin(), values.end());
1262       }
1263 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){
1264         if (index < 0)
1265           throw std::out_of_range("index");
1266         if (count < 0)
1267           throw std::out_of_range("count");
1268         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1269           throw std::invalid_argument("invalid range");
1270         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1271       }
1272 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){
1273         if (index>=0 && index<(int)self->size()+1)
1274           self->insert(self->begin()+index, x);
1275         else
1276           throw std::out_of_range("index");
1277       }
1278 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){
1279         if (index>=0 && index<(int)self->size()+1)
1280           self->insert(self->begin()+index, values.begin(), values.end());
1281         else
1282           throw std::out_of_range("index");
1283       }
1284 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){
1285         if (index>=0 && index<(int)self->size())
1286           self->erase(self->begin() + index);
1287         else
1288           throw std::out_of_range("index");
1289       }
1290 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){
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         self->erase(self->begin()+index, self->begin()+index+count);
1298       }
1299 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){
1300         if (count < 0)
1301           throw std::out_of_range("count");
1302         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1303       }
1304 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){
1305         std::reverse(self->begin(), self->end());
1306       }
1307 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){
1308         if (index < 0)
1309           throw std::out_of_range("index");
1310         if (count < 0)
1311           throw std::out_of_range("count");
1312         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1313           throw std::invalid_argument("invalid range");
1314         std::reverse(self->begin()+index, self->begin()+index+count);
1315       }
1316 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){
1317         if (index < 0)
1318           throw std::out_of_range("index");
1319         if (index+values.size() > self->size())
1320           throw std::out_of_range("index");
1321         std::copy(values.begin(), values.end(), self->begin()+index);
1322       }
1323 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1324         std::vector< Dali::Actor >* pv = 0;
1325         if (capacity >= 0) {
1326           pv = new std::vector< Dali::Actor >();
1327           pv->reserve(capacity);
1328        } else {
1329           throw std::out_of_range("capacity");
1330        }
1331        return pv;
1332       }
1333 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1334         if (index>=0 && index<(int)self->size())
1335           return (*self)[index];
1336         else
1337           throw std::out_of_range("index");
1338       }
1339 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1340         if (index>=0 && index<(int)self->size())
1341           return (*self)[index];
1342         else
1343           throw std::out_of_range("index");
1344       }
1345 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1346         if (index>=0 && index<(int)self->size())
1347           (*self)[index] = val;
1348         else
1349           throw std::out_of_range("index");
1350       }
1351 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1352         self->insert(self->end(), values.begin(), values.end());
1353       }
1354 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1355         if (index < 0)
1356           throw std::out_of_range("index");
1357         if (count < 0)
1358           throw std::out_of_range("count");
1359         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1360           throw std::invalid_argument("invalid range");
1361         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1362       }
1363 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1364         if (index>=0 && index<(int)self->size()+1)
1365           self->insert(self->begin()+index, x);
1366         else
1367           throw std::out_of_range("index");
1368       }
1369 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1370         if (index>=0 && index<(int)self->size()+1)
1371           self->insert(self->begin()+index, values.begin(), values.end());
1372         else
1373           throw std::out_of_range("index");
1374       }
1375 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1376         if (index>=0 && index<(int)self->size())
1377           self->erase(self->begin() + index);
1378         else
1379           throw std::out_of_range("index");
1380       }
1381 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(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         self->erase(self->begin()+index, self->begin()+index+count);
1389       }
1390 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1391         if (count < 0)
1392           throw std::out_of_range("count");
1393         return new std::vector< Dali::Actor >(count, value);
1394       }
1395 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1396         std::reverse(self->begin(), self->end());
1397       }
1398 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1399         if (index < 0)
1400           throw std::out_of_range("index");
1401         if (count < 0)
1402           throw std::out_of_range("count");
1403         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1404           throw std::invalid_argument("invalid range");
1405         std::reverse(self->begin()+index, self->begin()+index+count);
1406       }
1407 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1408         if (index < 0)
1409           throw std::out_of_range("index");
1410         if (index+values.size() > self->size())
1411           throw std::out_of_range("index");
1412         std::copy(values.begin(), values.end(), self->begin()+index);
1413       }
1414 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1415          return self->Empty();
1416       }
1417 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1418         return self->GetConnectionCount();
1419       }
1420 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 &)){
1421           self->Connect( func );
1422       }
1423 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 &)){
1424           self->Disconnect( func );
1425       }
1426 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){
1427           return self->Emit( arg );
1428       }
1429 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){
1430          return self->Empty();
1431       }
1432 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){
1433         return self->GetConnectionCount();
1434       }
1435 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)){
1436         self->Connect( func );
1437       }
1438 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)){
1439         self->Disconnect( func );
1440       }
1441 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){
1442         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1443 /*@SWIG@*/ self->Emit( arg1, arg2 );
1444       }
1445 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1446          return self->Empty();
1447       }
1448 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){
1449         return self->GetConnectionCount();
1450       }
1451 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)){
1452         self->Connect( func );
1453       }
1454 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)){
1455         self->Disconnect( func );
1456       }
1457 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){
1458         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1459 /*@SWIG@*/ self->Emit( arg1, arg2 );
1460       }
1461 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1462          return self->Empty();
1463       }
1464 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1465         return self->GetConnectionCount();
1466       }
1467 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)){
1468         self->Connect( func );
1469       }
1470 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)){
1471         self->Disconnect( func );
1472       }
1473 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){
1474         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1475 /*@SWIG@*/ self->Emit( arg1, arg2 );
1476       }
1477 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){
1478          return self->Empty();
1479       }
1480 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){
1481         return self->GetConnectionCount();
1482       }
1483 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)){
1484         self->Connect( func );
1485       }
1486 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)){
1487         self->Disconnect( func );
1488       }
1489 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){
1490         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1491 /*@SWIG@*/ self->Emit( arg1, arg2 );
1492       }
1493 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1494          return self->Empty();
1495       }
1496 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1497         return self->GetConnectionCount();
1498       }
1499 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)){
1500           self->Connect( func );
1501       }
1502 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)){
1503           self->Disconnect( func );
1504       }
1505 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1506           return self->Emit( arg );
1507       }
1508 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1509          return self->Empty();
1510       }
1511 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1512         return self->GetConnectionCount();
1513       }
1514 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)){
1515           self->Connect( func );
1516       }
1517 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)){
1518           self->Disconnect( func );
1519       }
1520 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1521           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1522 /*@SWIG@*/ self->Emit( arg );
1523       }
1524 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){
1525          return self->Empty();
1526       }
1527 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){
1528         return self->GetConnectionCount();
1529       }
1530 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)){
1531           return self->Connect( func );
1532       }
1533 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)){
1534           self->Disconnect( func );
1535       }
1536 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){
1537           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1538 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1539       }
1540 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1541          return self->Empty();
1542       }
1543 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1544         return self->GetConnectionCount();
1545       }
1546 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)){
1547           self->Connect( func );
1548       }
1549 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)){
1550           self->Disconnect( func );
1551       }
1552 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1553           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1554 /*@SWIG@*/ self->Emit( arg );
1555       }
1556 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){
1557          return self->Empty();
1558       }
1559 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){
1560         return self->GetConnectionCount();
1561       }
1562 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)){
1563           return self->Connect( func );
1564       }
1565 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)){
1566           self->Disconnect( func );
1567       }
1568 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){
1569           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1570 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1571       }
1572 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){
1573          return self->Empty();
1574       }
1575 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){
1576         return self->GetConnectionCount();
1577       }
1578 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 &)){
1579           self->Connect( func );
1580       }
1581 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 &)){
1582           self->Disconnect( func );
1583       }
1584 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){
1585           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1586 /*@SWIG@*/ self->Emit( arg );
1587       }
1588 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1589          return self->Empty();
1590       }
1591 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){
1592         return self->GetConnectionCount();
1593       }
1594 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 &)){
1595           self->Connect( func );
1596       }
1597 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 &)){
1598           self->Disconnect( func );
1599       }
1600 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){
1601           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1602 /*@SWIG@*/ self->Emit( arg );
1603       }
1604 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
1605          return self->Empty();
1606       }
1607 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
1608         return self->GetConnectionCount();
1609       }
1610 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)){
1611           self->Connect( func );
1612       }
1613 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)){
1614           self->Disconnect( func );
1615       }
1616 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,Dali::Toolkit::TextEditor arg){
1617           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1618 /*@SWIG@*/ self->Emit( arg );
1619       }
1620 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
1621          return self->Empty();
1622       }
1623 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
1624         return self->GetConnectionCount();
1625       }
1626 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)){
1627           self->Connect( func );
1628       }
1629 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)){
1630           self->Disconnect( func );
1631       }
1632 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextField) > *self,Dali::Toolkit::TextField arg){
1633           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1634 /*@SWIG@*/ self->Emit( arg );
1635       }
1636 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){
1637          return self->Empty();
1638       }
1639 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){
1640         return self->GetConnectionCount();
1641       }
1642 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 &)){
1643         self->Connect( func );
1644       }
1645 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 &)){
1646         self->Disconnect( func );
1647       }
1648 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){
1649         return self->Emit( arg1, arg2 );
1650       }
1651 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1652          return self->Empty();
1653       }
1654 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1655         return self->GetConnectionCount();
1656       }
1657 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)){
1658           self->Connect( func );
1659       }
1660 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)){
1661           self->Disconnect( func );
1662       }
1663 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1664           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1665 /*@SWIG@*/ self->Emit( arg );
1666       }
1667 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1668          return self->Empty();
1669       }
1670 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1671         return self->GetConnectionCount();
1672       }
1673 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 &)){
1674           self->Connect( func );
1675       }
1676 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 &)){
1677           self->Disconnect( func );
1678       }
1679 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){
1680           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1681 /*@SWIG@*/ self->Emit( arg );
1682       }
1683 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1684          return self->Empty();
1685       }
1686 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){
1687         return self->GetConnectionCount();
1688       }
1689 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)){
1690         self->Connect( func );
1691       }
1692 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)){
1693         self->Disconnect( func );
1694       }
1695 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){
1696         return self->Emit( arg1, arg2 );
1697       }
1698 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1699          return self->Empty();
1700       }
1701 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){
1702         return self->GetConnectionCount();
1703       }
1704 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)){
1705         self->Connect( func );
1706       }
1707 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)){
1708         self->Disconnect( func );
1709       }
1710 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){
1711         return self->Emit( arg1, arg2 );
1712       }
1713
1714
1715 /* ---------------------------------------------------
1716  * C++ director class methods
1717  * --------------------------------------------------- */
1718
1719 #include "dali_wrap.h"
1720
1721 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1722   swig_init_callbacks();
1723 }
1724
1725 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1726
1727 }
1728
1729
1730 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1731   int jdepth  ;
1732
1733   if (!swig_callbackOnStageConnection) {
1734     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1735     return;
1736   } else {
1737     jdepth = depth;
1738     swig_callbackOnStageConnection(jdepth);
1739   }
1740 }
1741
1742 void SwigDirector_ViewImpl::OnStageDisconnection() {
1743   if (!swig_callbackOnStageDisconnection) {
1744     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1745     return;
1746   } else {
1747     swig_callbackOnStageDisconnection();
1748   }
1749 }
1750
1751 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1752   void * jchild = 0 ;
1753
1754   if (!swig_callbackOnChildAdd) {
1755     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1756     return;
1757   } else {
1758     jchild = (Dali::Actor *) &child;
1759     swig_callbackOnChildAdd(jchild);
1760   }
1761 }
1762
1763 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1764   void * jchild = 0 ;
1765
1766   if (!swig_callbackOnChildRemove) {
1767     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1768     return;
1769   } else {
1770     jchild = (Dali::Actor *) &child;
1771     swig_callbackOnChildRemove(jchild);
1772   }
1773 }
1774
1775 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1776   int jindex  ;
1777   void * jpropertyValue  ;
1778
1779   if (!swig_callbackOnPropertySet) {
1780     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1781     return;
1782   } else {
1783     jindex = index;
1784     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1785     swig_callbackOnPropertySet(jindex, jpropertyValue);
1786   }
1787 }
1788
1789 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1790   void * jtargetSize = 0 ;
1791
1792   if (!swig_callbackOnSizeSet) {
1793     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1794     return;
1795   } else {
1796     jtargetSize = (Dali::Vector3 *) &targetSize;
1797     swig_callbackOnSizeSet(jtargetSize);
1798   }
1799 }
1800
1801 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1802   void * janimation = 0 ;
1803   void * jtargetSize = 0 ;
1804
1805   if (!swig_callbackOnSizeAnimation) {
1806     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1807     return;
1808   } else {
1809     janimation = (Dali::Animation *) &animation;
1810     jtargetSize = (Dali::Vector3 *) &targetSize;
1811     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1812   }
1813 }
1814
1815 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1816   bool c_result = SwigValueInit< bool >() ;
1817   unsigned int jresult = 0 ;
1818   void * jarg0 = 0 ;
1819
1820   if (!swig_callbackOnTouchEvent) {
1821     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1822   } else {
1823     jarg0 = (Dali::TouchEvent *) &event;
1824     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1825     c_result = jresult ? true : false;
1826   }
1827   return c_result;
1828 }
1829
1830 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1831   bool c_result = SwigValueInit< bool >() ;
1832   unsigned int jresult = 0 ;
1833   void * jarg0 = 0 ;
1834
1835   if (!swig_callbackOnHoverEvent) {
1836     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1837   } else {
1838     jarg0 = (Dali::HoverEvent *) &event;
1839     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1840     c_result = jresult ? true : false;
1841   }
1842   return c_result;
1843 }
1844
1845 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1846   bool c_result = SwigValueInit< bool >() ;
1847   unsigned int jresult = 0 ;
1848   void * jarg0 = 0 ;
1849
1850   if (!swig_callbackOnKeyEvent) {
1851     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1852   } else {
1853     jarg0 = (Dali::KeyEvent *) &event;
1854     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1855     c_result = jresult ? true : false;
1856   }
1857   return c_result;
1858 }
1859
1860 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1861   bool c_result = SwigValueInit< bool >() ;
1862   unsigned int jresult = 0 ;
1863   void * jarg0 = 0 ;
1864
1865   if (!swig_callbackOnWheelEvent) {
1866     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1867   } else {
1868     jarg0 = (Dali::WheelEvent *) &event;
1869     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1870     c_result = jresult ? true : false;
1871   }
1872   return c_result;
1873 }
1874
1875 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1876   void * jsize = 0 ;
1877   void * jcontainer = 0 ;
1878
1879   if (!swig_callbackOnRelayout) {
1880     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1881     return;
1882   } else {
1883     jsize = (Dali::Vector2 *) &size;
1884     jcontainer = (Dali::RelayoutContainer *) &container;
1885     swig_callbackOnRelayout(jsize, jcontainer);
1886   }
1887 }
1888
1889 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1890   int jpolicy  ;
1891   int jdimension  ;
1892
1893   if (!swig_callbackOnSetResizePolicy) {
1894     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1895     return;
1896   } else {
1897     jpolicy = (int)policy;
1898     jdimension = (int)dimension;
1899     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1900   }
1901 }
1902
1903 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1904   Dali::Vector3 c_result ;
1905   void * jresult = 0 ;
1906
1907   if (!swig_callbackGetNaturalSize) {
1908     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1909   } else {
1910     jresult = (void *) swig_callbackGetNaturalSize();
1911     if (!jresult) {
1912       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1913       return c_result;
1914     }
1915     c_result = *(Dali::Vector3 *)jresult;
1916   }
1917   return c_result;
1918 }
1919
1920 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
1921   float c_result = SwigValueInit< float >() ;
1922   float jresult = 0 ;
1923   void * jchild = 0 ;
1924   int jdimension  ;
1925
1926   if (!swig_callbackCalculateChildSize) {
1927     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
1928   } else {
1929     jchild = (Dali::Actor *) &child;
1930     jdimension = (int)dimension;
1931     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
1932     c_result = (float)jresult;
1933   }
1934   return c_result;
1935 }
1936
1937 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
1938   float c_result = SwigValueInit< float >() ;
1939   float jresult = 0 ;
1940   float jwidth  ;
1941
1942   if (!swig_callbackGetHeightForWidth) {
1943     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
1944   } else {
1945     jwidth = width;
1946     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
1947     c_result = (float)jresult;
1948   }
1949   return c_result;
1950 }
1951
1952 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
1953   float c_result = SwigValueInit< float >() ;
1954   float jresult = 0 ;
1955   float jheight  ;
1956
1957   if (!swig_callbackGetWidthForHeight) {
1958     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
1959   } else {
1960     jheight = height;
1961     jresult = (float) swig_callbackGetWidthForHeight(jheight);
1962     c_result = (float)jresult;
1963   }
1964   return c_result;
1965 }
1966
1967 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
1968   bool c_result = SwigValueInit< bool >() ;
1969   unsigned int jresult = 0 ;
1970   int jdimension  ;
1971
1972   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
1973     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
1974   } else {
1975     jdimension = (int)dimension;
1976     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
1977     c_result = jresult ? true : false;
1978   }
1979   return c_result;
1980 }
1981
1982 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
1983   int jdimension  ;
1984
1985   if (!swig_callbackOnCalculateRelayoutSize) {
1986     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
1987     return;
1988   } else {
1989     jdimension = (int)dimension;
1990     swig_callbackOnCalculateRelayoutSize(jdimension);
1991   }
1992 }
1993
1994 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
1995   float jsize  ;
1996   int jdimension  ;
1997
1998   if (!swig_callbackOnLayoutNegotiated) {
1999     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2000     return;
2001   } else {
2002     jsize = size;
2003     jdimension = (int)dimension;
2004     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2005   }
2006 }
2007
2008 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2009   return Dali::CustomActorImpl::GetExtension();
2010 }
2011
2012 void SwigDirector_ViewImpl::OnInitialize() {
2013   if (!swig_callbackOnInitialize) {
2014     Dali::Toolkit::Internal::Control::OnInitialize();
2015     return;
2016   } else {
2017     swig_callbackOnInitialize();
2018   }
2019 }
2020
2021 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
2022   void * jchild = 0 ;
2023
2024   if (!swig_callbackOnControlChildAdd) {
2025     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
2026     return;
2027   } else {
2028     jchild = (Dali::Actor *) &child;
2029     swig_callbackOnControlChildAdd(jchild);
2030   }
2031 }
2032
2033 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
2034   void * jchild = 0 ;
2035
2036   if (!swig_callbackOnControlChildRemove) {
2037     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2038     return;
2039   } else {
2040     jchild = (Dali::Actor *) &child;
2041     swig_callbackOnControlChildRemove(jchild);
2042   }
2043 }
2044
2045 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2046   void * jstyleManager  ;
2047   int jchange  ;
2048
2049   if (!swig_callbackOnStyleChange) {
2050     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2051     return;
2052   } else {
2053     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2054     jchange = (int)change;
2055     swig_callbackOnStyleChange(jstyleManager, jchange);
2056   }
2057 }
2058
2059 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2060   bool c_result = SwigValueInit< bool >() ;
2061   unsigned int jresult = 0 ;
2062
2063   if (!swig_callbackOnAccessibilityActivated) {
2064     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2065   } else {
2066     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2067     c_result = jresult ? true : false;
2068   }
2069   return c_result;
2070 }
2071
2072 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2073   bool c_result = SwigValueInit< bool >() ;
2074   unsigned int jresult = 0 ;
2075   void * jgesture  ;
2076
2077   if (!swig_callbackOnAccessibilityPan) {
2078     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2079   } else {
2080     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2081     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2082     c_result = jresult ? true : false;
2083   }
2084   return c_result;
2085 }
2086
2087 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2088   bool c_result = SwigValueInit< bool >() ;
2089   unsigned int jresult = 0 ;
2090   void * jtouchEvent = 0 ;
2091
2092   if (!swig_callbackOnAccessibilityTouch) {
2093     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2094   } else {
2095     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2096     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2097     c_result = jresult ? true : false;
2098   }
2099   return c_result;
2100 }
2101
2102 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2103   bool c_result = SwigValueInit< bool >() ;
2104   unsigned int jresult = 0 ;
2105   unsigned int jisIncrease  ;
2106
2107   if (!swig_callbackOnAccessibilityValueChange) {
2108     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2109   } else {
2110     jisIncrease = isIncrease;
2111     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2112     c_result = jresult ? true : false;
2113   }
2114   return c_result;
2115 }
2116
2117 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2118   bool c_result = SwigValueInit< bool >() ;
2119   unsigned int jresult = 0 ;
2120
2121   if (!swig_callbackOnAccessibilityZoom) {
2122     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2123   } else {
2124     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2125     c_result = jresult ? true : false;
2126   }
2127   return c_result;
2128 }
2129
2130 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2131   if (!swig_callbackOnKeyInputFocusGained) {
2132     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2133     return;
2134   } else {
2135     swig_callbackOnKeyInputFocusGained();
2136   }
2137 }
2138
2139 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2140   if (!swig_callbackOnKeyInputFocusLost) {
2141     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2142     return;
2143   } else {
2144     swig_callbackOnKeyInputFocusLost();
2145   }
2146 }
2147
2148 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2149   Dali::Actor c_result ;
2150   void * jresult = 0 ;
2151   void * jcurrentFocusedActor  ;
2152   int jdirection  ;
2153   unsigned int jloopEnabled  ;
2154
2155   if (!swig_callbackGetNextKeyboardFocusableActor) {
2156     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2157   } else {
2158     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2159     jdirection = (int)direction;
2160     jloopEnabled = loopEnabled;
2161     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2162     if (!jresult) {
2163       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2164       return c_result;
2165     }
2166     c_result = *(Dali::Actor *)jresult;
2167   }
2168   return c_result;
2169 }
2170
2171 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2172   void * jcommitedFocusableActor  ;
2173
2174   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2175     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2176     return;
2177   } else {
2178     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2179     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2180   }
2181 }
2182
2183 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2184   bool c_result = SwigValueInit< bool >() ;
2185   unsigned int jresult = 0 ;
2186
2187   if (!swig_callbackOnKeyboardEnter) {
2188     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2189   } else {
2190     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2191     c_result = jresult ? true : false;
2192   }
2193   return c_result;
2194 }
2195
2196 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2197   void * jpinch = 0 ;
2198
2199   if (!swig_callbackOnPinch) {
2200     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2201     return;
2202   } else {
2203     jpinch = (Dali::PinchGesture *) &pinch;
2204     swig_callbackOnPinch(jpinch);
2205   }
2206 }
2207
2208 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2209   void * jpan = 0 ;
2210
2211   if (!swig_callbackOnPan) {
2212     Dali::Toolkit::Internal::Control::OnPan(pan);
2213     return;
2214   } else {
2215     jpan = (Dali::PanGesture *) &pan;
2216     swig_callbackOnPan(jpan);
2217   }
2218 }
2219
2220 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2221   void * jtap = 0 ;
2222
2223   if (!swig_callbackOnTap) {
2224     Dali::Toolkit::Internal::Control::OnTap(tap);
2225     return;
2226   } else {
2227     jtap = (Dali::TapGesture *) &tap;
2228     swig_callbackOnTap(jtap);
2229   }
2230 }
2231
2232 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2233   void * jlongPress = 0 ;
2234
2235   if (!swig_callbackOnLongPress) {
2236     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2237     return;
2238   } else {
2239     jlongPress = (Dali::LongPressGesture *) &longPress;
2240     swig_callbackOnLongPress(jlongPress);
2241   }
2242 }
2243
2244 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2245   void * jslotObserver = 0 ;
2246   void * jcallback = 0 ;
2247
2248   if (!swig_callbackSignalConnected) {
2249     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2250     return;
2251   } else {
2252     jslotObserver = (void *) slotObserver;
2253     jcallback = (void *) callback;
2254     swig_callbackSignalConnected(jslotObserver, jcallback);
2255   }
2256 }
2257
2258 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2259   void * jslotObserver = 0 ;
2260   void * jcallback = 0 ;
2261
2262   if (!swig_callbackSignalDisconnected) {
2263     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2264     return;
2265   } else {
2266     jslotObserver = (void *) slotObserver;
2267     jcallback = (void *) callback;
2268     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2269   }
2270 }
2271
2272 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2273   return Dali::Toolkit::Internal::Control::GetControlExtension();
2274 }
2275
2276 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) {
2277   swig_callbackOnStageConnection = callbackOnStageConnection;
2278   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2279   swig_callbackOnChildAdd = callbackOnChildAdd;
2280   swig_callbackOnChildRemove = callbackOnChildRemove;
2281   swig_callbackOnPropertySet = callbackOnPropertySet;
2282   swig_callbackOnSizeSet = callbackOnSizeSet;
2283   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2284   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2285   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2286   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2287   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2288   swig_callbackOnRelayout = callbackOnRelayout;
2289   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2290   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2291   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2292   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2293   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2294   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2295   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2296   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2297   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2298   swig_callbackOnInitialize = callbackOnInitialize;
2299   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2300   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2301   swig_callbackOnStyleChange = callbackOnStyleChange;
2302   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2303   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2304   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2305   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2306   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2307   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2308   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2309   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2310   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2311   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2312   swig_callbackOnPinch = callbackOnPinch;
2313   swig_callbackOnPan = callbackOnPan;
2314   swig_callbackOnTap = callbackOnTap;
2315   swig_callbackOnLongPress = callbackOnLongPress;
2316   swig_callbackSignalConnected = callbackSignalConnected;
2317   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2318 }
2319
2320 void SwigDirector_ViewImpl::swig_init_callbacks() {
2321   swig_callbackOnStageConnection = 0;
2322   swig_callbackOnStageDisconnection = 0;
2323   swig_callbackOnChildAdd = 0;
2324   swig_callbackOnChildRemove = 0;
2325   swig_callbackOnPropertySet = 0;
2326   swig_callbackOnSizeSet = 0;
2327   swig_callbackOnSizeAnimation = 0;
2328   swig_callbackOnTouchEvent = 0;
2329   swig_callbackOnHoverEvent = 0;
2330   swig_callbackOnKeyEvent = 0;
2331   swig_callbackOnWheelEvent = 0;
2332   swig_callbackOnRelayout = 0;
2333   swig_callbackOnSetResizePolicy = 0;
2334   swig_callbackGetNaturalSize = 0;
2335   swig_callbackCalculateChildSize = 0;
2336   swig_callbackGetHeightForWidth = 0;
2337   swig_callbackGetWidthForHeight = 0;
2338   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2339   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2340   swig_callbackOnCalculateRelayoutSize = 0;
2341   swig_callbackOnLayoutNegotiated = 0;
2342   swig_callbackOnInitialize = 0;
2343   swig_callbackOnControlChildAdd = 0;
2344   swig_callbackOnControlChildRemove = 0;
2345   swig_callbackOnStyleChange = 0;
2346   swig_callbackOnAccessibilityActivated = 0;
2347   swig_callbackOnAccessibilityPan = 0;
2348   swig_callbackOnAccessibilityTouch = 0;
2349   swig_callbackOnAccessibilityValueChange = 0;
2350   swig_callbackOnAccessibilityZoom = 0;
2351   swig_callbackOnKeyInputFocusGained = 0;
2352   swig_callbackOnKeyInputFocusLost = 0;
2353   swig_callbackGetNextKeyboardFocusableActor = 0;
2354   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2355   swig_callbackOnKeyboardEnter = 0;
2356   swig_callbackOnPinch = 0;
2357   swig_callbackOnPan = 0;
2358   swig_callbackOnTap = 0;
2359   swig_callbackOnLongPress = 0;
2360   swig_callbackSignalConnected = 0;
2361   swig_callbackSignalDisconnected = 0;
2362 }
2363
2364 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2365   swig_init_callbacks();
2366 }
2367
2368 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2369
2370 }
2371
2372
2373 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2374   unsigned int c_result = SwigValueInit< unsigned int >() ;
2375   unsigned int jresult = 0 ;
2376
2377   if (!swig_callbackGetNumberOfItems) {
2378     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2379   } else {
2380     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2381     c_result = (unsigned int)jresult;
2382   }
2383   return c_result;
2384 }
2385
2386 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2387   Dali::Actor c_result ;
2388   void * jresult = 0 ;
2389   unsigned int jitemId  ;
2390
2391   if (!swig_callbackNewItem) {
2392     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2393   } else {
2394     jitemId = itemId;
2395     jresult = (void *) swig_callbackNewItem(jitemId);
2396     if (!jresult) {
2397       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2398       return c_result;
2399     }
2400     c_result = *(Dali::Actor *)jresult;
2401   }
2402   return c_result;
2403 }
2404
2405 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2406   unsigned int jitemId  ;
2407   void * jactor  ;
2408
2409   if (!swig_callbackItemReleased) {
2410     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2411     return;
2412   } else {
2413     jitemId = itemId;
2414     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2415     swig_callbackItemReleased(jitemId, jactor);
2416   }
2417 }
2418
2419 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2420   return Dali::Toolkit::ItemFactory::GetExtension();
2421 }
2422
2423 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2424   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2425   swig_callbackNewItem = callbackNewItem;
2426   swig_callbackItemReleased = callbackItemReleased;
2427 }
2428
2429 void SwigDirector_ItemFactory::swig_init_callbacks() {
2430   swig_callbackGetNumberOfItems = 0;
2431   swig_callbackNewItem = 0;
2432   swig_callbackItemReleased = 0;
2433 }
2434
2435 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2436   swig_init_callbacks();
2437 }
2438
2439 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2440
2441 }
2442
2443
2444 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2445   Dali::Actor c_result ;
2446   void * jresult = 0 ;
2447   void * jcurrent  ;
2448   void * jproposed  ;
2449   int jdirection  ;
2450
2451   if (!swig_callbackGetNextFocusableActor) {
2452     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2453   } else {
2454     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2455     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2456     jdirection = (int)direction;
2457     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2458     if (!jresult) {
2459       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2460       return c_result;
2461     }
2462     c_result = *(Dali::Actor *)jresult;
2463   }
2464   return c_result;
2465 }
2466
2467 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2468   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2469 }
2470
2471 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2472   swig_callbackGetNextFocusableActor = 0;
2473 }
2474
2475
2476 #ifdef __cplusplus
2477 extern "C" {
2478 #endif
2479
2480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2481   void * jresult ;
2482   floatp *result = 0 ;
2483
2484   {
2485     try {
2486       result = (floatp *)new_floatp();
2487     } catch (std::out_of_range& e) {
2488       {
2489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2490       };
2491     } catch (std::exception& e) {
2492       {
2493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2494       };
2495     } catch (...) {
2496       {
2497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2498       };
2499     }
2500   }
2501   jresult = (void *)result;
2502   return jresult;
2503 }
2504
2505
2506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2507   floatp *arg1 = (floatp *) 0 ;
2508
2509   arg1 = (floatp *)jarg1;
2510   {
2511     try {
2512       delete_floatp(arg1);
2513     } catch (std::out_of_range& e) {
2514       {
2515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2516       };
2517     } catch (std::exception& e) {
2518       {
2519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2520       };
2521     } catch (...) {
2522       {
2523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2524       };
2525     }
2526   }
2527 }
2528
2529
2530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2531   floatp *arg1 = (floatp *) 0 ;
2532   float arg2 ;
2533
2534   arg1 = (floatp *)jarg1;
2535   arg2 = (float)jarg2;
2536   {
2537     try {
2538       floatp_assign(arg1,arg2);
2539     } catch (std::out_of_range& e) {
2540       {
2541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2542       };
2543     } catch (std::exception& e) {
2544       {
2545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2546       };
2547     } catch (...) {
2548       {
2549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2550       };
2551     }
2552   }
2553 }
2554
2555
2556 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2557   float jresult ;
2558   floatp *arg1 = (floatp *) 0 ;
2559   float result;
2560
2561   arg1 = (floatp *)jarg1;
2562   {
2563     try {
2564       result = (float)floatp_value(arg1);
2565     } catch (std::out_of_range& e) {
2566       {
2567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2568       };
2569     } catch (std::exception& e) {
2570       {
2571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2572       };
2573     } catch (...) {
2574       {
2575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2576       };
2577     }
2578   }
2579   jresult = result;
2580   return jresult;
2581 }
2582
2583
2584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2585   void * jresult ;
2586   floatp *arg1 = (floatp *) 0 ;
2587   float *result = 0 ;
2588
2589   arg1 = (floatp *)jarg1;
2590   {
2591     try {
2592       result = (float *)floatp_cast(arg1);
2593     } catch (std::out_of_range& e) {
2594       {
2595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2596       };
2597     } catch (std::exception& e) {
2598       {
2599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2600       };
2601     } catch (...) {
2602       {
2603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2604       };
2605     }
2606   }
2607   jresult = (void *)result;
2608   return jresult;
2609 }
2610
2611
2612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2613   void * jresult ;
2614   float *arg1 = (float *) 0 ;
2615   floatp *result = 0 ;
2616
2617   arg1 = (float *)jarg1;
2618   {
2619     try {
2620       result = (floatp *)floatp_frompointer(arg1);
2621     } catch (std::out_of_range& e) {
2622       {
2623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2624       };
2625     } catch (std::exception& e) {
2626       {
2627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2628       };
2629     } catch (...) {
2630       {
2631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2632       };
2633     }
2634   }
2635   jresult = (void *)result;
2636   return jresult;
2637 }
2638
2639
2640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2641   void * jresult ;
2642   intp *result = 0 ;
2643
2644   {
2645     try {
2646       result = (intp *)new_intp();
2647     } catch (std::out_of_range& e) {
2648       {
2649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2650       };
2651     } catch (std::exception& e) {
2652       {
2653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2654       };
2655     } catch (...) {
2656       {
2657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2658       };
2659     }
2660   }
2661   jresult = (void *)result;
2662   return jresult;
2663 }
2664
2665
2666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2667   intp *arg1 = (intp *) 0 ;
2668
2669   arg1 = (intp *)jarg1;
2670   {
2671     try {
2672       delete_intp(arg1);
2673     } catch (std::out_of_range& e) {
2674       {
2675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2676       };
2677     } catch (std::exception& e) {
2678       {
2679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2680       };
2681     } catch (...) {
2682       {
2683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2684       };
2685     }
2686   }
2687 }
2688
2689
2690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2691   intp *arg1 = (intp *) 0 ;
2692   int arg2 ;
2693
2694   arg1 = (intp *)jarg1;
2695   arg2 = (int)jarg2;
2696   {
2697     try {
2698       intp_assign(arg1,arg2);
2699     } catch (std::out_of_range& e) {
2700       {
2701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2702       };
2703     } catch (std::exception& e) {
2704       {
2705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2706       };
2707     } catch (...) {
2708       {
2709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2710       };
2711     }
2712   }
2713 }
2714
2715
2716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2717   int jresult ;
2718   intp *arg1 = (intp *) 0 ;
2719   int result;
2720
2721   arg1 = (intp *)jarg1;
2722   {
2723     try {
2724       result = (int)intp_value(arg1);
2725     } catch (std::out_of_range& e) {
2726       {
2727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2728       };
2729     } catch (std::exception& e) {
2730       {
2731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2732       };
2733     } catch (...) {
2734       {
2735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2736       };
2737     }
2738   }
2739   jresult = result;
2740   return jresult;
2741 }
2742
2743
2744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2745   void * jresult ;
2746   intp *arg1 = (intp *) 0 ;
2747   int *result = 0 ;
2748
2749   arg1 = (intp *)jarg1;
2750   {
2751     try {
2752       result = (int *)intp_cast(arg1);
2753     } catch (std::out_of_range& e) {
2754       {
2755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2756       };
2757     } catch (std::exception& e) {
2758       {
2759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2760       };
2761     } catch (...) {
2762       {
2763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2764       };
2765     }
2766   }
2767   jresult = (void *)result;
2768   return jresult;
2769 }
2770
2771
2772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2773   void * jresult ;
2774   int *arg1 = (int *) 0 ;
2775   intp *result = 0 ;
2776
2777   arg1 = (int *)jarg1;
2778   {
2779     try {
2780       result = (intp *)intp_frompointer(arg1);
2781     } catch (std::out_of_range& e) {
2782       {
2783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2784       };
2785     } catch (std::exception& e) {
2786       {
2787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2788       };
2789     } catch (...) {
2790       {
2791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2792       };
2793     }
2794   }
2795   jresult = (void *)result;
2796   return jresult;
2797 }
2798
2799
2800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2801   void * jresult ;
2802   doublep *result = 0 ;
2803
2804   {
2805     try {
2806       result = (doublep *)new_doublep();
2807     } catch (std::out_of_range& e) {
2808       {
2809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2810       };
2811     } catch (std::exception& e) {
2812       {
2813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2814       };
2815     } catch (...) {
2816       {
2817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2818       };
2819     }
2820   }
2821   jresult = (void *)result;
2822   return jresult;
2823 }
2824
2825
2826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2827   doublep *arg1 = (doublep *) 0 ;
2828
2829   arg1 = (doublep *)jarg1;
2830   {
2831     try {
2832       delete_doublep(arg1);
2833     } catch (std::out_of_range& e) {
2834       {
2835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2836       };
2837     } catch (std::exception& e) {
2838       {
2839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2840       };
2841     } catch (...) {
2842       {
2843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2844       };
2845     }
2846   }
2847 }
2848
2849
2850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2851   doublep *arg1 = (doublep *) 0 ;
2852   double arg2 ;
2853
2854   arg1 = (doublep *)jarg1;
2855   arg2 = (double)jarg2;
2856   {
2857     try {
2858       doublep_assign(arg1,arg2);
2859     } catch (std::out_of_range& e) {
2860       {
2861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2862       };
2863     } catch (std::exception& e) {
2864       {
2865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2866       };
2867     } catch (...) {
2868       {
2869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2870       };
2871     }
2872   }
2873 }
2874
2875
2876 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
2877   double jresult ;
2878   doublep *arg1 = (doublep *) 0 ;
2879   double result;
2880
2881   arg1 = (doublep *)jarg1;
2882   {
2883     try {
2884       result = (double)doublep_value(arg1);
2885     } catch (std::out_of_range& e) {
2886       {
2887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2888       };
2889     } catch (std::exception& e) {
2890       {
2891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2892       };
2893     } catch (...) {
2894       {
2895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2896       };
2897     }
2898   }
2899   jresult = result;
2900   return jresult;
2901 }
2902
2903
2904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
2905   void * jresult ;
2906   doublep *arg1 = (doublep *) 0 ;
2907   double *result = 0 ;
2908
2909   arg1 = (doublep *)jarg1;
2910   {
2911     try {
2912       result = (double *)doublep_cast(arg1);
2913     } catch (std::out_of_range& e) {
2914       {
2915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2916       };
2917     } catch (std::exception& e) {
2918       {
2919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2920       };
2921     } catch (...) {
2922       {
2923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2924       };
2925     }
2926   }
2927   jresult = (void *)result;
2928   return jresult;
2929 }
2930
2931
2932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
2933   void * jresult ;
2934   double *arg1 = (double *) 0 ;
2935   doublep *result = 0 ;
2936
2937   arg1 = (double *)jarg1;
2938   {
2939     try {
2940       result = (doublep *)doublep_frompointer(arg1);
2941     } catch (std::out_of_range& e) {
2942       {
2943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2944       };
2945     } catch (std::exception& e) {
2946       {
2947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2948       };
2949     } catch (...) {
2950       {
2951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2952       };
2953     }
2954   }
2955   jresult = (void *)result;
2956   return jresult;
2957 }
2958
2959
2960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
2961   void * jresult ;
2962   uintp *result = 0 ;
2963
2964   {
2965     try {
2966       result = (uintp *)new_uintp();
2967     } catch (std::out_of_range& e) {
2968       {
2969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2970       };
2971     } catch (std::exception& e) {
2972       {
2973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2974       };
2975     } catch (...) {
2976       {
2977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2978       };
2979     }
2980   }
2981   jresult = (void *)result;
2982   return jresult;
2983 }
2984
2985
2986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
2987   uintp *arg1 = (uintp *) 0 ;
2988
2989   arg1 = (uintp *)jarg1;
2990   {
2991     try {
2992       delete_uintp(arg1);
2993     } catch (std::out_of_range& e) {
2994       {
2995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2996       };
2997     } catch (std::exception& e) {
2998       {
2999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3000       };
3001     } catch (...) {
3002       {
3003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3004       };
3005     }
3006   }
3007 }
3008
3009
3010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3011   uintp *arg1 = (uintp *) 0 ;
3012   unsigned int arg2 ;
3013
3014   arg1 = (uintp *)jarg1;
3015   arg2 = (unsigned int)jarg2;
3016   {
3017     try {
3018       uintp_assign(arg1,arg2);
3019     } catch (std::out_of_range& e) {
3020       {
3021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3022       };
3023     } catch (std::exception& e) {
3024       {
3025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3026       };
3027     } catch (...) {
3028       {
3029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3030       };
3031     }
3032   }
3033 }
3034
3035
3036 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3037   unsigned int jresult ;
3038   uintp *arg1 = (uintp *) 0 ;
3039   unsigned int result;
3040
3041   arg1 = (uintp *)jarg1;
3042   {
3043     try {
3044       result = (unsigned int)uintp_value(arg1);
3045     } catch (std::out_of_range& e) {
3046       {
3047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3048       };
3049     } catch (std::exception& e) {
3050       {
3051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3052       };
3053     } catch (...) {
3054       {
3055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3056       };
3057     }
3058   }
3059   jresult = result;
3060   return jresult;
3061 }
3062
3063
3064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3065   void * jresult ;
3066   uintp *arg1 = (uintp *) 0 ;
3067   unsigned int *result = 0 ;
3068
3069   arg1 = (uintp *)jarg1;
3070   {
3071     try {
3072       result = (unsigned int *)uintp_cast(arg1);
3073     } catch (std::out_of_range& e) {
3074       {
3075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3076       };
3077     } catch (std::exception& e) {
3078       {
3079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3080       };
3081     } catch (...) {
3082       {
3083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3084       };
3085     }
3086   }
3087   jresult = (void *)result;
3088   return jresult;
3089 }
3090
3091
3092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3093   void * jresult ;
3094   unsigned int *arg1 = (unsigned int *) 0 ;
3095   uintp *result = 0 ;
3096
3097   arg1 = (unsigned int *)jarg1;
3098   {
3099     try {
3100       result = (uintp *)uintp_frompointer(arg1);
3101     } catch (std::out_of_range& e) {
3102       {
3103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3104       };
3105     } catch (std::exception& e) {
3106       {
3107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3108       };
3109     } catch (...) {
3110       {
3111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3112       };
3113     }
3114   }
3115   jresult = (void *)result;
3116   return jresult;
3117 }
3118
3119
3120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3121   void * jresult ;
3122   ushortp *result = 0 ;
3123
3124   {
3125     try {
3126       result = (ushortp *)new_ushortp();
3127     } catch (std::out_of_range& e) {
3128       {
3129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3130       };
3131     } catch (std::exception& e) {
3132       {
3133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3134       };
3135     } catch (...) {
3136       {
3137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3138       };
3139     }
3140   }
3141   jresult = (void *)result;
3142   return jresult;
3143 }
3144
3145
3146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3147   ushortp *arg1 = (ushortp *) 0 ;
3148
3149   arg1 = (ushortp *)jarg1;
3150   {
3151     try {
3152       delete_ushortp(arg1);
3153     } catch (std::out_of_range& e) {
3154       {
3155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3156       };
3157     } catch (std::exception& e) {
3158       {
3159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3160       };
3161     } catch (...) {
3162       {
3163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3164       };
3165     }
3166   }
3167 }
3168
3169
3170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3171   ushortp *arg1 = (ushortp *) 0 ;
3172   unsigned short arg2 ;
3173
3174   arg1 = (ushortp *)jarg1;
3175   arg2 = (unsigned short)jarg2;
3176   {
3177     try {
3178       ushortp_assign(arg1,arg2);
3179     } catch (std::out_of_range& e) {
3180       {
3181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3182       };
3183     } catch (std::exception& e) {
3184       {
3185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3186       };
3187     } catch (...) {
3188       {
3189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3190       };
3191     }
3192   }
3193 }
3194
3195
3196 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3197   unsigned short jresult ;
3198   ushortp *arg1 = (ushortp *) 0 ;
3199   unsigned short result;
3200
3201   arg1 = (ushortp *)jarg1;
3202   {
3203     try {
3204       result = (unsigned short)ushortp_value(arg1);
3205     } catch (std::out_of_range& e) {
3206       {
3207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3208       };
3209     } catch (std::exception& e) {
3210       {
3211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3212       };
3213     } catch (...) {
3214       {
3215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3216       };
3217     }
3218   }
3219   jresult = result;
3220   return jresult;
3221 }
3222
3223
3224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3225   void * jresult ;
3226   ushortp *arg1 = (ushortp *) 0 ;
3227   unsigned short *result = 0 ;
3228
3229   arg1 = (ushortp *)jarg1;
3230   {
3231     try {
3232       result = (unsigned short *)ushortp_cast(arg1);
3233     } catch (std::out_of_range& e) {
3234       {
3235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3236       };
3237     } catch (std::exception& e) {
3238       {
3239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3240       };
3241     } catch (...) {
3242       {
3243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3244       };
3245     }
3246   }
3247   jresult = (void *)result;
3248   return jresult;
3249 }
3250
3251
3252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3253   void * jresult ;
3254   unsigned short *arg1 = (unsigned short *) 0 ;
3255   ushortp *result = 0 ;
3256
3257   arg1 = (unsigned short *)jarg1;
3258   {
3259     try {
3260       result = (ushortp *)ushortp_frompointer(arg1);
3261     } catch (std::out_of_range& e) {
3262       {
3263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3264       };
3265     } catch (std::exception& e) {
3266       {
3267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3268       };
3269     } catch (...) {
3270       {
3271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3272       };
3273     }
3274   }
3275   jresult = (void *)result;
3276   return jresult;
3277 }
3278
3279
3280 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3281   unsigned int jresult ;
3282   int arg1 ;
3283   unsigned int result;
3284
3285   arg1 = (int)jarg1;
3286   {
3287     try {
3288       result = (unsigned int)int_to_uint(arg1);
3289     } catch (std::out_of_range& e) {
3290       {
3291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3292       };
3293     } catch (std::exception& e) {
3294       {
3295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3296       };
3297     } catch (...) {
3298       {
3299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3300       };
3301     }
3302   }
3303   jresult = result;
3304   return jresult;
3305 }
3306
3307
3308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3309   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3310
3311   arg1 = (Dali::RefObject *)jarg1;
3312   {
3313     try {
3314       (arg1)->Reference();
3315     } catch (std::out_of_range& e) {
3316       {
3317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3318       };
3319     } catch (std::exception& e) {
3320       {
3321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3322       };
3323     } catch (...) {
3324       {
3325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3326       };
3327     }
3328   }
3329 }
3330
3331
3332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3333   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3334
3335   arg1 = (Dali::RefObject *)jarg1;
3336   {
3337     try {
3338       (arg1)->Unreference();
3339     } catch (std::out_of_range& e) {
3340       {
3341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3342       };
3343     } catch (std::exception& e) {
3344       {
3345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3346       };
3347     } catch (...) {
3348       {
3349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3350       };
3351     }
3352   }
3353 }
3354
3355
3356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3357   int jresult ;
3358   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3359   int result;
3360
3361   arg1 = (Dali::RefObject *)jarg1;
3362   {
3363     try {
3364       result = (int)(arg1)->ReferenceCount();
3365     } catch (std::out_of_range& e) {
3366       {
3367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3368       };
3369     } catch (std::exception& e) {
3370       {
3371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3372       };
3373     } catch (...) {
3374       {
3375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3376       };
3377     }
3378   }
3379   jresult = result;
3380   return jresult;
3381 }
3382
3383
3384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3385   void * jresult ;
3386   Dali::Any *result = 0 ;
3387
3388   {
3389     try {
3390       result = (Dali::Any *)new Dali::Any();
3391     } catch (std::out_of_range& e) {
3392       {
3393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3394       };
3395     } catch (std::exception& e) {
3396       {
3397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3398       };
3399     } catch (...) {
3400       {
3401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3402       };
3403     }
3404   }
3405   jresult = (void *)result;
3406   return jresult;
3407 }
3408
3409
3410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3411   Dali::Any *arg1 = (Dali::Any *) 0 ;
3412
3413   arg1 = (Dali::Any *)jarg1;
3414   {
3415     try {
3416       delete arg1;
3417     } catch (std::out_of_range& e) {
3418       {
3419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3420       };
3421     } catch (std::exception& e) {
3422       {
3423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3424       };
3425     } catch (...) {
3426       {
3427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3428       };
3429     }
3430   }
3431 }
3432
3433
3434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3435   char *arg1 = (char *) 0 ;
3436
3437   arg1 = (char *)jarg1;
3438   {
3439     try {
3440       Dali::Any::AssertAlways((char const *)arg1);
3441     } catch (std::out_of_range& e) {
3442       {
3443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3444       };
3445     } catch (std::exception& e) {
3446       {
3447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3448       };
3449     } catch (...) {
3450       {
3451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3452       };
3453     }
3454   }
3455 }
3456
3457
3458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3459   void * jresult ;
3460   Dali::Any *arg1 = 0 ;
3461   Dali::Any *result = 0 ;
3462
3463   arg1 = (Dali::Any *)jarg1;
3464   if (!arg1) {
3465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3466     return 0;
3467   }
3468   {
3469     try {
3470       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3471     } catch (std::out_of_range& e) {
3472       {
3473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3474       };
3475     } catch (std::exception& e) {
3476       {
3477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3478       };
3479     } catch (...) {
3480       {
3481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3482       };
3483     }
3484   }
3485   jresult = (void *)result;
3486   return jresult;
3487 }
3488
3489
3490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3491   void * jresult ;
3492   Dali::Any *arg1 = (Dali::Any *) 0 ;
3493   Dali::Any *arg2 = 0 ;
3494   Dali::Any *result = 0 ;
3495
3496   arg1 = (Dali::Any *)jarg1;
3497   arg2 = (Dali::Any *)jarg2;
3498   if (!arg2) {
3499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3500     return 0;
3501   }
3502   {
3503     try {
3504       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3505     } catch (std::out_of_range& e) {
3506       {
3507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3508       };
3509     } catch (std::exception& e) {
3510       {
3511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3512       };
3513     } catch (...) {
3514       {
3515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3516       };
3517     }
3518   }
3519   jresult = (void *)result;
3520   return jresult;
3521 }
3522
3523
3524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3525   void * jresult ;
3526   Dali::Any *arg1 = (Dali::Any *) 0 ;
3527   std::type_info *result = 0 ;
3528
3529   arg1 = (Dali::Any *)jarg1;
3530   {
3531     try {
3532       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3533     } catch (std::out_of_range& e) {
3534       {
3535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3536       };
3537     } catch (std::exception& e) {
3538       {
3539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3540       };
3541     } catch (...) {
3542       {
3543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3544       };
3545     }
3546   }
3547   jresult = (void *)result;
3548   return jresult;
3549 }
3550
3551
3552 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3553   unsigned int jresult ;
3554   Dali::Any *arg1 = (Dali::Any *) 0 ;
3555   bool result;
3556
3557   arg1 = (Dali::Any *)jarg1;
3558   {
3559     try {
3560       result = (bool)((Dali::Any const *)arg1)->Empty();
3561     } catch (std::out_of_range& e) {
3562       {
3563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3564       };
3565     } catch (std::exception& e) {
3566       {
3567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3568       };
3569     } catch (...) {
3570       {
3571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3572       };
3573     }
3574   }
3575   jresult = result;
3576   return jresult;
3577 }
3578
3579
3580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3581   void * jresult ;
3582   std::type_info *arg1 = 0 ;
3583   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3584   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3585   Dali::Any::AnyContainerBase *result = 0 ;
3586
3587   arg1 = (std::type_info *)jarg1;
3588   if (!arg1) {
3589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3590     return 0;
3591   }
3592   arg2 = (Dali::Any::CloneFunc)jarg2;
3593   arg3 = (Dali::Any::DeleteFunc)jarg3;
3594   {
3595     try {
3596       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3597     } catch (std::out_of_range& e) {
3598       {
3599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3600       };
3601     } catch (std::exception& e) {
3602       {
3603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3604       };
3605     } catch (...) {
3606       {
3607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3608       };
3609     }
3610   }
3611   jresult = (void *)result;
3612   return jresult;
3613 }
3614
3615
3616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3617   void * jresult ;
3618   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3619   std::type_info *result = 0 ;
3620
3621   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3622   {
3623     try {
3624       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3625     } catch (std::out_of_range& e) {
3626       {
3627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3628       };
3629     } catch (std::exception& e) {
3630       {
3631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3632       };
3633     } catch (...) {
3634       {
3635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3636       };
3637     }
3638   }
3639   jresult = (void *)result;
3640   return jresult;
3641 }
3642
3643
3644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3645   void * jresult ;
3646   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3647   ::std::type_info *result = 0 ;
3648
3649   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3650   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3651   jresult = (void *)result;
3652   return jresult;
3653 }
3654
3655
3656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3657   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3658   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3659
3660   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3661   arg2 = (Dali::Any::CloneFunc)jarg2;
3662   if (arg1) (arg1)->mCloneFunc = arg2;
3663 }
3664
3665
3666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3667   void * jresult ;
3668   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3669   Dali::Any::CloneFunc result;
3670
3671   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3672   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3673   jresult = (void *)result;
3674   return jresult;
3675 }
3676
3677
3678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3679   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3680   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3681
3682   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3683   arg2 = (Dali::Any::DeleteFunc)jarg2;
3684   if (arg1) (arg1)->mDeleteFunc = arg2;
3685 }
3686
3687
3688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3689   void * jresult ;
3690   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3691   Dali::Any::DeleteFunc result;
3692
3693   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3694   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3695   jresult = (void *)result;
3696   return jresult;
3697 }
3698
3699
3700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
3701   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3702
3703   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3704   {
3705     try {
3706       delete arg1;
3707     } catch (std::out_of_range& e) {
3708       {
3709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3710       };
3711     } catch (std::exception& e) {
3712       {
3713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3714       };
3715     } catch (...) {
3716       {
3717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3718       };
3719     }
3720   }
3721 }
3722
3723
3724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
3725   Dali::Any *arg1 = (Dali::Any *) 0 ;
3726   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
3727
3728   arg1 = (Dali::Any *)jarg1;
3729   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
3730   if (arg1) (arg1)->mContainer = arg2;
3731 }
3732
3733
3734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
3735   void * jresult ;
3736   Dali::Any *arg1 = (Dali::Any *) 0 ;
3737   Dali::Any::AnyContainerBase *result = 0 ;
3738
3739   arg1 = (Dali::Any *)jarg1;
3740   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
3741   jresult = (void *)result;
3742   return jresult;
3743 }
3744
3745
3746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
3747   char *arg1 = (char *) 0 ;
3748   char *arg2 = (char *) 0 ;
3749
3750   arg1 = (char *)jarg1;
3751   arg2 = (char *)jarg2;
3752   {
3753     try {
3754       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
3755     } catch (std::out_of_range& e) {
3756       {
3757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3758       };
3759     } catch (std::exception& e) {
3760       {
3761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3762       };
3763     } catch (...) {
3764       {
3765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3766       };
3767     }
3768   }
3769 }
3770
3771
3772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
3773   void * jresult ;
3774   char *arg1 = (char *) 0 ;
3775   char *arg2 = (char *) 0 ;
3776   Dali::DaliException *result = 0 ;
3777
3778   arg1 = (char *)jarg1;
3779   arg2 = (char *)jarg2;
3780   {
3781     try {
3782       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
3783     } catch (std::out_of_range& e) {
3784       {
3785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3786       };
3787     } catch (std::exception& e) {
3788       {
3789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3790       };
3791     } catch (...) {
3792       {
3793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3794       };
3795     }
3796   }
3797   jresult = (void *)result;
3798   return jresult;
3799 }
3800
3801
3802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
3803   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3804   char *arg2 = (char *) 0 ;
3805
3806   arg1 = (Dali::DaliException *)jarg1;
3807   arg2 = (char *)jarg2;
3808   {
3809     if (arg2) {
3810       arg1->location = (char const *) (new char[strlen((const char *)arg2)+1]);
3811       strcpy((char *)arg1->location, (const char *)arg2);
3812     } else {
3813       arg1->location = 0;
3814     }
3815   }
3816 }
3817
3818
3819 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
3820   char * jresult ;
3821   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3822   char *result = 0 ;
3823
3824   arg1 = (Dali::DaliException *)jarg1;
3825   result = (char *) ((arg1)->location);
3826   jresult = SWIG_csharp_string_callback((const char *)result);
3827   return jresult;
3828 }
3829
3830
3831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
3832   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3833   char *arg2 = (char *) 0 ;
3834
3835   arg1 = (Dali::DaliException *)jarg1;
3836   arg2 = (char *)jarg2;
3837   {
3838     if (arg2) {
3839       arg1->condition = (char const *) (new char[strlen((const char *)arg2)+1]);
3840       strcpy((char *)arg1->condition, (const char *)arg2);
3841     } else {
3842       arg1->condition = 0;
3843     }
3844   }
3845 }
3846
3847
3848 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
3849   char * jresult ;
3850   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3851   char *result = 0 ;
3852
3853   arg1 = (Dali::DaliException *)jarg1;
3854   result = (char *) ((arg1)->condition);
3855   jresult = SWIG_csharp_string_callback((const char *)result);
3856   return jresult;
3857 }
3858
3859
3860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
3861   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3862
3863   arg1 = (Dali::DaliException *)jarg1;
3864   {
3865     try {
3866       delete arg1;
3867     } catch (std::out_of_range& e) {
3868       {
3869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3870       };
3871     } catch (std::exception& e) {
3872       {
3873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3874       };
3875     } catch (...) {
3876       {
3877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3878       };
3879     }
3880   }
3881 }
3882
3883
3884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
3885   void * jresult ;
3886   Dali::Vector2 *result = 0 ;
3887
3888   {
3889     try {
3890       result = (Dali::Vector2 *)new Dali::Vector2();
3891     } catch (std::out_of_range& e) {
3892       {
3893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3894       };
3895     } catch (std::exception& e) {
3896       {
3897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3898       };
3899     } catch (...) {
3900       {
3901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3902       };
3903     }
3904   }
3905   jresult = (void *)result;
3906   return jresult;
3907 }
3908
3909
3910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
3911   void * jresult ;
3912   float arg1 ;
3913   float arg2 ;
3914   Dali::Vector2 *result = 0 ;
3915
3916   arg1 = (float)jarg1;
3917   arg2 = (float)jarg2;
3918   {
3919     try {
3920       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
3921     } catch (std::out_of_range& e) {
3922       {
3923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3924       };
3925     } catch (std::exception& e) {
3926       {
3927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3928       };
3929     } catch (...) {
3930       {
3931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3932       };
3933     }
3934   }
3935   jresult = (void *)result;
3936   return jresult;
3937 }
3938
3939
3940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
3941   void * jresult ;
3942   float *arg1 = (float *) 0 ;
3943   Dali::Vector2 *result = 0 ;
3944
3945   arg1 = jarg1;
3946   {
3947     try {
3948       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
3949     } catch (std::out_of_range& e) {
3950       {
3951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3952       };
3953     } catch (std::exception& e) {
3954       {
3955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3956       };
3957     } catch (...) {
3958       {
3959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3960       };
3961     }
3962   }
3963   jresult = (void *)result;
3964
3965
3966   return jresult;
3967 }
3968
3969
3970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
3971   void * jresult ;
3972   Dali::Vector3 *arg1 = 0 ;
3973   Dali::Vector2 *result = 0 ;
3974
3975   arg1 = (Dali::Vector3 *)jarg1;
3976   if (!arg1) {
3977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3978     return 0;
3979   }
3980   {
3981     try {
3982       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
3983     } catch (std::out_of_range& e) {
3984       {
3985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3986       };
3987     } catch (std::exception& e) {
3988       {
3989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3990       };
3991     } catch (...) {
3992       {
3993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3994       };
3995     }
3996   }
3997   jresult = (void *)result;
3998   return jresult;
3999 }
4000
4001
4002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4003   void * jresult ;
4004   Dali::Vector4 *arg1 = 0 ;
4005   Dali::Vector2 *result = 0 ;
4006
4007   arg1 = (Dali::Vector4 *)jarg1;
4008   if (!arg1) {
4009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4010     return 0;
4011   }
4012   {
4013     try {
4014       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4015     } catch (std::out_of_range& e) {
4016       {
4017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4018       };
4019     } catch (std::exception& e) {
4020       {
4021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4022       };
4023     } catch (...) {
4024       {
4025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4026       };
4027     }
4028   }
4029   jresult = (void *)result;
4030   return jresult;
4031 }
4032
4033
4034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4035   void * jresult ;
4036   Dali::Vector2 *result = 0 ;
4037
4038   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4039   jresult = (void *)result;
4040   return jresult;
4041 }
4042
4043
4044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4045   void * jresult ;
4046   Dali::Vector2 *result = 0 ;
4047
4048   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4049   jresult = (void *)result;
4050   return jresult;
4051 }
4052
4053
4054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4055   void * jresult ;
4056   Dali::Vector2 *result = 0 ;
4057
4058   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4059   jresult = (void *)result;
4060   return jresult;
4061 }
4062
4063
4064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4065   void * jresult ;
4066   Dali::Vector2 *result = 0 ;
4067
4068   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4069   jresult = (void *)result;
4070   return jresult;
4071 }
4072
4073
4074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4075   void * jresult ;
4076   Dali::Vector2 *result = 0 ;
4077
4078   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4079   jresult = (void *)result;
4080   return jresult;
4081 }
4082
4083
4084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4085   void * jresult ;
4086   Dali::Vector2 *result = 0 ;
4087
4088   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4089   jresult = (void *)result;
4090   return jresult;
4091 }
4092
4093
4094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4095   void * jresult ;
4096   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4097   float *arg2 = (float *) 0 ;
4098   Dali::Vector2 *result = 0 ;
4099
4100   arg1 = (Dali::Vector2 *)jarg1;
4101   arg2 = jarg2;
4102   {
4103     try {
4104       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4105     } catch (std::out_of_range& e) {
4106       {
4107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4108       };
4109     } catch (std::exception& e) {
4110       {
4111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4112       };
4113     } catch (...) {
4114       {
4115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4116       };
4117     }
4118   }
4119   jresult = (void *)result;
4120
4121
4122   return jresult;
4123 }
4124
4125
4126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4127   void * jresult ;
4128   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4129   Dali::Vector3 *arg2 = 0 ;
4130   Dali::Vector2 *result = 0 ;
4131
4132   arg1 = (Dali::Vector2 *)jarg1;
4133   arg2 = (Dali::Vector3 *)jarg2;
4134   if (!arg2) {
4135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4136     return 0;
4137   }
4138   {
4139     try {
4140       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4141     } catch (std::out_of_range& e) {
4142       {
4143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4144       };
4145     } catch (std::exception& e) {
4146       {
4147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4148       };
4149     } catch (...) {
4150       {
4151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4152       };
4153     }
4154   }
4155   jresult = (void *)result;
4156   return jresult;
4157 }
4158
4159
4160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4161   void * jresult ;
4162   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4163   Dali::Vector4 *arg2 = 0 ;
4164   Dali::Vector2 *result = 0 ;
4165
4166   arg1 = (Dali::Vector2 *)jarg1;
4167   arg2 = (Dali::Vector4 *)jarg2;
4168   if (!arg2) {
4169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4170     return 0;
4171   }
4172   {
4173     try {
4174       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4175     } catch (std::out_of_range& e) {
4176       {
4177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4178       };
4179     } catch (std::exception& e) {
4180       {
4181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4182       };
4183     } catch (...) {
4184       {
4185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4186       };
4187     }
4188   }
4189   jresult = (void *)result;
4190   return jresult;
4191 }
4192
4193
4194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4195   void * jresult ;
4196   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4197   Dali::Vector2 *arg2 = 0 ;
4198   Dali::Vector2 result;
4199
4200   arg1 = (Dali::Vector2 *)jarg1;
4201   arg2 = (Dali::Vector2 *)jarg2;
4202   if (!arg2) {
4203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4204     return 0;
4205   }
4206   {
4207     try {
4208       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4209     } catch (std::out_of_range& e) {
4210       {
4211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4212       };
4213     } catch (std::exception& e) {
4214       {
4215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4216       };
4217     } catch (...) {
4218       {
4219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4220       };
4221     }
4222   }
4223   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4224   return jresult;
4225 }
4226
4227
4228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4229   void * jresult ;
4230   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4231   Dali::Vector2 *arg2 = 0 ;
4232   Dali::Vector2 *result = 0 ;
4233
4234   arg1 = (Dali::Vector2 *)jarg1;
4235   arg2 = (Dali::Vector2 *)jarg2;
4236   if (!arg2) {
4237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4238     return 0;
4239   }
4240   {
4241     try {
4242       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4243     } catch (std::out_of_range& e) {
4244       {
4245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4246       };
4247     } catch (std::exception& e) {
4248       {
4249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4250       };
4251     } catch (...) {
4252       {
4253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4254       };
4255     }
4256   }
4257   jresult = (void *)result;
4258   return jresult;
4259 }
4260
4261
4262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4263   void * jresult ;
4264   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4265   Dali::Vector2 *arg2 = 0 ;
4266   Dali::Vector2 result;
4267
4268   arg1 = (Dali::Vector2 *)jarg1;
4269   arg2 = (Dali::Vector2 *)jarg2;
4270   if (!arg2) {
4271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4272     return 0;
4273   }
4274   {
4275     try {
4276       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4277     } catch (std::out_of_range& e) {
4278       {
4279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4280       };
4281     } catch (std::exception& e) {
4282       {
4283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4284       };
4285     } catch (...) {
4286       {
4287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4288       };
4289     }
4290   }
4291   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4292   return jresult;
4293 }
4294
4295
4296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4297   void * jresult ;
4298   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4299   Dali::Vector2 *arg2 = 0 ;
4300   Dali::Vector2 *result = 0 ;
4301
4302   arg1 = (Dali::Vector2 *)jarg1;
4303   arg2 = (Dali::Vector2 *)jarg2;
4304   if (!arg2) {
4305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4306     return 0;
4307   }
4308   {
4309     try {
4310       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4311     } catch (std::out_of_range& e) {
4312       {
4313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4314       };
4315     } catch (std::exception& e) {
4316       {
4317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4318       };
4319     } catch (...) {
4320       {
4321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4322       };
4323     }
4324   }
4325   jresult = (void *)result;
4326   return jresult;
4327 }
4328
4329
4330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4331   void * jresult ;
4332   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4333   Dali::Vector2 *arg2 = 0 ;
4334   Dali::Vector2 result;
4335
4336   arg1 = (Dali::Vector2 *)jarg1;
4337   arg2 = (Dali::Vector2 *)jarg2;
4338   if (!arg2) {
4339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4340     return 0;
4341   }
4342   {
4343     try {
4344       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4345     } catch (std::out_of_range& e) {
4346       {
4347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4348       };
4349     } catch (std::exception& e) {
4350       {
4351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4352       };
4353     } catch (...) {
4354       {
4355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4356       };
4357     }
4358   }
4359   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4360   return jresult;
4361 }
4362
4363
4364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4365   void * jresult ;
4366   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4367   float arg2 ;
4368   Dali::Vector2 result;
4369
4370   arg1 = (Dali::Vector2 *)jarg1;
4371   arg2 = (float)jarg2;
4372   {
4373     try {
4374       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4375     } catch (std::out_of_range& e) {
4376       {
4377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4378       };
4379     } catch (std::exception& e) {
4380       {
4381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4382       };
4383     } catch (...) {
4384       {
4385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4386       };
4387     }
4388   }
4389   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4390   return jresult;
4391 }
4392
4393
4394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4395   void * jresult ;
4396   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4397   Dali::Vector2 *arg2 = 0 ;
4398   Dali::Vector2 *result = 0 ;
4399
4400   arg1 = (Dali::Vector2 *)jarg1;
4401   arg2 = (Dali::Vector2 *)jarg2;
4402   if (!arg2) {
4403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4404     return 0;
4405   }
4406   {
4407     try {
4408       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4409     } catch (std::out_of_range& e) {
4410       {
4411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4412       };
4413     } catch (std::exception& e) {
4414       {
4415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4416       };
4417     } catch (...) {
4418       {
4419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4420       };
4421     }
4422   }
4423   jresult = (void *)result;
4424   return jresult;
4425 }
4426
4427
4428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4429   void * jresult ;
4430   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4431   float arg2 ;
4432   Dali::Vector2 *result = 0 ;
4433
4434   arg1 = (Dali::Vector2 *)jarg1;
4435   arg2 = (float)jarg2;
4436   {
4437     try {
4438       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4439     } catch (std::out_of_range& e) {
4440       {
4441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4442       };
4443     } catch (std::exception& e) {
4444       {
4445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4446       };
4447     } catch (...) {
4448       {
4449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4450       };
4451     }
4452   }
4453   jresult = (void *)result;
4454   return jresult;
4455 }
4456
4457
4458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4459   void * jresult ;
4460   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4461   Dali::Vector2 *arg2 = 0 ;
4462   Dali::Vector2 result;
4463
4464   arg1 = (Dali::Vector2 *)jarg1;
4465   arg2 = (Dali::Vector2 *)jarg2;
4466   if (!arg2) {
4467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4468     return 0;
4469   }
4470   {
4471     try {
4472       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4473     } catch (std::out_of_range& e) {
4474       {
4475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4476       };
4477     } catch (std::exception& e) {
4478       {
4479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4480       };
4481     } catch (...) {
4482       {
4483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4484       };
4485     }
4486   }
4487   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4488   return jresult;
4489 }
4490
4491
4492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4493   void * jresult ;
4494   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4495   float arg2 ;
4496   Dali::Vector2 result;
4497
4498   arg1 = (Dali::Vector2 *)jarg1;
4499   arg2 = (float)jarg2;
4500   {
4501     try {
4502       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4503     } catch (std::out_of_range& e) {
4504       {
4505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4506       };
4507     } catch (std::exception& e) {
4508       {
4509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4510       };
4511     } catch (...) {
4512       {
4513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4514       };
4515     }
4516   }
4517   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4518   return jresult;
4519 }
4520
4521
4522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4523   void * jresult ;
4524   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4525   Dali::Vector2 *arg2 = 0 ;
4526   Dali::Vector2 *result = 0 ;
4527
4528   arg1 = (Dali::Vector2 *)jarg1;
4529   arg2 = (Dali::Vector2 *)jarg2;
4530   if (!arg2) {
4531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4532     return 0;
4533   }
4534   {
4535     try {
4536       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4537     } catch (std::out_of_range& e) {
4538       {
4539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4540       };
4541     } catch (std::exception& e) {
4542       {
4543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4544       };
4545     } catch (...) {
4546       {
4547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4548       };
4549     }
4550   }
4551   jresult = (void *)result;
4552   return jresult;
4553 }
4554
4555
4556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4557   void * jresult ;
4558   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4559   float arg2 ;
4560   Dali::Vector2 *result = 0 ;
4561
4562   arg1 = (Dali::Vector2 *)jarg1;
4563   arg2 = (float)jarg2;
4564   {
4565     try {
4566       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4567     } catch (std::out_of_range& e) {
4568       {
4569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4570       };
4571     } catch (std::exception& e) {
4572       {
4573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4574       };
4575     } catch (...) {
4576       {
4577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4578       };
4579     }
4580   }
4581   jresult = (void *)result;
4582   return jresult;
4583 }
4584
4585
4586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
4587   void * jresult ;
4588   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4589   Dali::Vector2 result;
4590
4591   arg1 = (Dali::Vector2 *)jarg1;
4592   {
4593     try {
4594       result = ((Dali::Vector2 const *)arg1)->operator -();
4595     } catch (std::out_of_range& e) {
4596       {
4597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4598       };
4599     } catch (std::exception& e) {
4600       {
4601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4602       };
4603     } catch (...) {
4604       {
4605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4606       };
4607     }
4608   }
4609   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4610   return jresult;
4611 }
4612
4613
4614 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
4615   unsigned int jresult ;
4616   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4617   Dali::Vector2 *arg2 = 0 ;
4618   bool result;
4619
4620   arg1 = (Dali::Vector2 *)jarg1;
4621   arg2 = (Dali::Vector2 *)jarg2;
4622   if (!arg2) {
4623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4624     return 0;
4625   }
4626   {
4627     try {
4628       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
4629     } catch (std::out_of_range& e) {
4630       {
4631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4632       };
4633     } catch (std::exception& e) {
4634       {
4635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4636       };
4637     } catch (...) {
4638       {
4639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4640       };
4641     }
4642   }
4643   jresult = result;
4644   return jresult;
4645 }
4646
4647
4648 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
4649   unsigned int jresult ;
4650   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4651   Dali::Vector2 *arg2 = 0 ;
4652   bool result;
4653
4654   arg1 = (Dali::Vector2 *)jarg1;
4655   arg2 = (Dali::Vector2 *)jarg2;
4656   if (!arg2) {
4657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4658     return 0;
4659   }
4660   {
4661     try {
4662       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
4663     } catch (std::out_of_range& e) {
4664       {
4665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4666       };
4667     } catch (std::exception& e) {
4668       {
4669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4670       };
4671     } catch (...) {
4672       {
4673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4674       };
4675     }
4676   }
4677   jresult = result;
4678   return jresult;
4679 }
4680
4681
4682 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
4683   float jresult ;
4684   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4685   unsigned int arg2 ;
4686   float *result = 0 ;
4687
4688   arg1 = (Dali::Vector2 *)jarg1;
4689   arg2 = (unsigned int)jarg2;
4690   {
4691     try {
4692       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
4693     } catch (std::out_of_range& e) {
4694       {
4695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4696       };
4697     } catch (std::exception& e) {
4698       {
4699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4700       };
4701     } catch (...) {
4702       {
4703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4704       };
4705     }
4706   }
4707   jresult = *result;
4708   return jresult;
4709 }
4710
4711
4712 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
4713   float jresult ;
4714   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4715   float result;
4716
4717   arg1 = (Dali::Vector2 *)jarg1;
4718   {
4719     try {
4720       result = (float)((Dali::Vector2 const *)arg1)->Length();
4721     } catch (std::out_of_range& e) {
4722       {
4723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4724       };
4725     } catch (std::exception& e) {
4726       {
4727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4728       };
4729     } catch (...) {
4730       {
4731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4732       };
4733     }
4734   }
4735   jresult = result;
4736   return jresult;
4737 }
4738
4739
4740 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
4741   float jresult ;
4742   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4743   float result;
4744
4745   arg1 = (Dali::Vector2 *)jarg1;
4746   {
4747     try {
4748       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
4749     } catch (std::out_of_range& e) {
4750       {
4751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4752       };
4753     } catch (std::exception& e) {
4754       {
4755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4756       };
4757     } catch (...) {
4758       {
4759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4760       };
4761     }
4762   }
4763   jresult = result;
4764   return jresult;
4765 }
4766
4767
4768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
4769   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4770
4771   arg1 = (Dali::Vector2 *)jarg1;
4772   {
4773     try {
4774       (arg1)->Normalize();
4775     } catch (std::out_of_range& e) {
4776       {
4777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4778       };
4779     } catch (std::exception& e) {
4780       {
4781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4782       };
4783     } catch (...) {
4784       {
4785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4786       };
4787     }
4788   }
4789 }
4790
4791
4792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
4793   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4794   Dali::Vector2 *arg2 = 0 ;
4795   Dali::Vector2 *arg3 = 0 ;
4796
4797   arg1 = (Dali::Vector2 *)jarg1;
4798   arg2 = (Dali::Vector2 *)jarg2;
4799   if (!arg2) {
4800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4801     return ;
4802   }
4803   arg3 = (Dali::Vector2 *)jarg3;
4804   if (!arg3) {
4805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4806     return ;
4807   }
4808   {
4809     try {
4810       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
4811     } catch (std::out_of_range& e) {
4812       {
4813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4814       };
4815     } catch (std::exception& e) {
4816       {
4817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4818       };
4819     } catch (...) {
4820       {
4821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4822       };
4823     }
4824   }
4825 }
4826
4827
4828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
4829   void * jresult ;
4830   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4831   float *result = 0 ;
4832
4833   arg1 = (Dali::Vector2 *)jarg1;
4834   {
4835     try {
4836       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
4837     } catch (std::out_of_range& e) {
4838       {
4839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4840       };
4841     } catch (std::exception& e) {
4842       {
4843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4844       };
4845     } catch (...) {
4846       {
4847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4848       };
4849     }
4850   }
4851   jresult = (void *)result;
4852   return jresult;
4853 }
4854
4855
4856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
4857   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4858   float arg2 ;
4859
4860   arg1 = (Dali::Vector2 *)jarg1;
4861   arg2 = (float)jarg2;
4862   if (arg1) (arg1)->x = arg2;
4863 }
4864
4865
4866 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
4867   float jresult ;
4868   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4869   float result;
4870
4871   arg1 = (Dali::Vector2 *)jarg1;
4872   result = (float) ((arg1)->x);
4873   jresult = result;
4874   return jresult;
4875 }
4876
4877
4878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
4879   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4880   float arg2 ;
4881
4882   arg1 = (Dali::Vector2 *)jarg1;
4883   arg2 = (float)jarg2;
4884   if (arg1) (arg1)->width = arg2;
4885 }
4886
4887
4888 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
4889   float jresult ;
4890   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4891   float result;
4892
4893   arg1 = (Dali::Vector2 *)jarg1;
4894   result = (float) ((arg1)->width);
4895   jresult = result;
4896   return jresult;
4897 }
4898
4899
4900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
4901   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4902   float arg2 ;
4903
4904   arg1 = (Dali::Vector2 *)jarg1;
4905   arg2 = (float)jarg2;
4906   if (arg1) (arg1)->y = arg2;
4907 }
4908
4909
4910 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
4911   float jresult ;
4912   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4913   float result;
4914
4915   arg1 = (Dali::Vector2 *)jarg1;
4916   result = (float) ((arg1)->y);
4917   jresult = result;
4918   return jresult;
4919 }
4920
4921
4922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
4923   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4924   float arg2 ;
4925
4926   arg1 = (Dali::Vector2 *)jarg1;
4927   arg2 = (float)jarg2;
4928   if (arg1) (arg1)->height = arg2;
4929 }
4930
4931
4932 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
4933   float jresult ;
4934   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4935   float result;
4936
4937   arg1 = (Dali::Vector2 *)jarg1;
4938   result = (float) ((arg1)->height);
4939   jresult = result;
4940   return jresult;
4941 }
4942
4943
4944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
4945   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4946
4947   arg1 = (Dali::Vector2 *)jarg1;
4948   {
4949     try {
4950       delete arg1;
4951     } catch (std::out_of_range& e) {
4952       {
4953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4954       };
4955     } catch (std::exception& e) {
4956       {
4957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4958       };
4959     } catch (...) {
4960       {
4961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4962       };
4963     }
4964   }
4965 }
4966
4967
4968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
4969   void * jresult ;
4970   Dali::Vector2 *arg1 = 0 ;
4971   Dali::Vector2 *arg2 = 0 ;
4972   Dali::Vector2 result;
4973
4974   arg1 = (Dali::Vector2 *)jarg1;
4975   if (!arg1) {
4976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4977     return 0;
4978   }
4979   arg2 = (Dali::Vector2 *)jarg2;
4980   if (!arg2) {
4981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4982     return 0;
4983   }
4984   {
4985     try {
4986       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4987     } catch (std::out_of_range& e) {
4988       {
4989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4990       };
4991     } catch (std::exception& e) {
4992       {
4993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4994       };
4995     } catch (...) {
4996       {
4997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4998       };
4999     }
5000   }
5001   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5002   return jresult;
5003 }
5004
5005
5006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5007   void * jresult ;
5008   Dali::Vector2 *arg1 = 0 ;
5009   Dali::Vector2 *arg2 = 0 ;
5010   Dali::Vector2 result;
5011
5012   arg1 = (Dali::Vector2 *)jarg1;
5013   if (!arg1) {
5014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5015     return 0;
5016   }
5017   arg2 = (Dali::Vector2 *)jarg2;
5018   if (!arg2) {
5019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5020     return 0;
5021   }
5022   {
5023     try {
5024       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5025     } catch (std::out_of_range& e) {
5026       {
5027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5028       };
5029     } catch (std::exception& e) {
5030       {
5031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5032       };
5033     } catch (...) {
5034       {
5035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5036       };
5037     }
5038   }
5039   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5040   return jresult;
5041 }
5042
5043
5044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5045   void * jresult ;
5046   Dali::Vector2 *arg1 = 0 ;
5047   float *arg2 = 0 ;
5048   float *arg3 = 0 ;
5049   float temp2 ;
5050   float temp3 ;
5051   Dali::Vector2 result;
5052
5053   arg1 = (Dali::Vector2 *)jarg1;
5054   if (!arg1) {
5055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5056     return 0;
5057   }
5058   temp2 = (float)jarg2;
5059   arg2 = &temp2;
5060   temp3 = (float)jarg3;
5061   arg3 = &temp3;
5062   {
5063     try {
5064       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5065     } catch (std::out_of_range& e) {
5066       {
5067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5068       };
5069     } catch (std::exception& e) {
5070       {
5071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5072       };
5073     } catch (...) {
5074       {
5075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5076       };
5077     }
5078   }
5079   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5080   return jresult;
5081 }
5082
5083
5084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5085   void * jresult ;
5086   Dali::Vector3 *result = 0 ;
5087
5088   {
5089     try {
5090       result = (Dali::Vector3 *)new Dali::Vector3();
5091     } catch (std::out_of_range& e) {
5092       {
5093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5094       };
5095     } catch (std::exception& e) {
5096       {
5097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5098       };
5099     } catch (...) {
5100       {
5101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5102       };
5103     }
5104   }
5105   jresult = (void *)result;
5106   return jresult;
5107 }
5108
5109
5110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5111   void * jresult ;
5112   float arg1 ;
5113   float arg2 ;
5114   float arg3 ;
5115   Dali::Vector3 *result = 0 ;
5116
5117   arg1 = (float)jarg1;
5118   arg2 = (float)jarg2;
5119   arg3 = (float)jarg3;
5120   {
5121     try {
5122       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5123     } catch (std::out_of_range& e) {
5124       {
5125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5126       };
5127     } catch (std::exception& e) {
5128       {
5129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5130       };
5131     } catch (...) {
5132       {
5133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5134       };
5135     }
5136   }
5137   jresult = (void *)result;
5138   return jresult;
5139 }
5140
5141
5142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5143   void * jresult ;
5144   float *arg1 = (float *) 0 ;
5145   Dali::Vector3 *result = 0 ;
5146
5147   arg1 = jarg1;
5148   {
5149     try {
5150       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5151     } catch (std::out_of_range& e) {
5152       {
5153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5154       };
5155     } catch (std::exception& e) {
5156       {
5157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5158       };
5159     } catch (...) {
5160       {
5161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5162       };
5163     }
5164   }
5165   jresult = (void *)result;
5166
5167
5168   return jresult;
5169 }
5170
5171
5172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5173   void * jresult ;
5174   Dali::Vector2 *arg1 = 0 ;
5175   Dali::Vector3 *result = 0 ;
5176
5177   arg1 = (Dali::Vector2 *)jarg1;
5178   if (!arg1) {
5179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5180     return 0;
5181   }
5182   {
5183     try {
5184       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5185     } catch (std::out_of_range& e) {
5186       {
5187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5188       };
5189     } catch (std::exception& e) {
5190       {
5191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5192       };
5193     } catch (...) {
5194       {
5195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5196       };
5197     }
5198   }
5199   jresult = (void *)result;
5200   return jresult;
5201 }
5202
5203
5204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5205   void * jresult ;
5206   Dali::Vector4 *arg1 = 0 ;
5207   Dali::Vector3 *result = 0 ;
5208
5209   arg1 = (Dali::Vector4 *)jarg1;
5210   if (!arg1) {
5211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5212     return 0;
5213   }
5214   {
5215     try {
5216       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5217     } catch (std::out_of_range& e) {
5218       {
5219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5220       };
5221     } catch (std::exception& e) {
5222       {
5223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5224       };
5225     } catch (...) {
5226       {
5227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5228       };
5229     }
5230   }
5231   jresult = (void *)result;
5232   return jresult;
5233 }
5234
5235
5236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5237   void * jresult ;
5238   Dali::Vector3 *result = 0 ;
5239
5240   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5241   jresult = (void *)result;
5242   return jresult;
5243 }
5244
5245
5246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5247   void * jresult ;
5248   Dali::Vector3 *result = 0 ;
5249
5250   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5251   jresult = (void *)result;
5252   return jresult;
5253 }
5254
5255
5256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5257   void * jresult ;
5258   Dali::Vector3 *result = 0 ;
5259
5260   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5261   jresult = (void *)result;
5262   return jresult;
5263 }
5264
5265
5266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5267   void * jresult ;
5268   Dali::Vector3 *result = 0 ;
5269
5270   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5271   jresult = (void *)result;
5272   return jresult;
5273 }
5274
5275
5276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5277   void * jresult ;
5278   Dali::Vector3 *result = 0 ;
5279
5280   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5281   jresult = (void *)result;
5282   return jresult;
5283 }
5284
5285
5286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5287   void * jresult ;
5288   Dali::Vector3 *result = 0 ;
5289
5290   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5291   jresult = (void *)result;
5292   return jresult;
5293 }
5294
5295
5296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5297   void * jresult ;
5298   Dali::Vector3 *result = 0 ;
5299
5300   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5301   jresult = (void *)result;
5302   return jresult;
5303 }
5304
5305
5306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5307   void * jresult ;
5308   Dali::Vector3 *result = 0 ;
5309
5310   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5311   jresult = (void *)result;
5312   return jresult;
5313 }
5314
5315
5316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5317   void * jresult ;
5318   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5319   float *arg2 = (float *) 0 ;
5320   Dali::Vector3 *result = 0 ;
5321
5322   arg1 = (Dali::Vector3 *)jarg1;
5323   arg2 = jarg2;
5324   {
5325     try {
5326       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5327     } catch (std::out_of_range& e) {
5328       {
5329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5330       };
5331     } catch (std::exception& e) {
5332       {
5333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5334       };
5335     } catch (...) {
5336       {
5337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5338       };
5339     }
5340   }
5341   jresult = (void *)result;
5342
5343
5344   return jresult;
5345 }
5346
5347
5348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5349   void * jresult ;
5350   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5351   Dali::Vector2 *arg2 = 0 ;
5352   Dali::Vector3 *result = 0 ;
5353
5354   arg1 = (Dali::Vector3 *)jarg1;
5355   arg2 = (Dali::Vector2 *)jarg2;
5356   if (!arg2) {
5357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5358     return 0;
5359   }
5360   {
5361     try {
5362       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5363     } catch (std::out_of_range& e) {
5364       {
5365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5366       };
5367     } catch (std::exception& e) {
5368       {
5369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5370       };
5371     } catch (...) {
5372       {
5373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5374       };
5375     }
5376   }
5377   jresult = (void *)result;
5378   return jresult;
5379 }
5380
5381
5382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5383   void * jresult ;
5384   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5385   Dali::Vector4 *arg2 = 0 ;
5386   Dali::Vector3 *result = 0 ;
5387
5388   arg1 = (Dali::Vector3 *)jarg1;
5389   arg2 = (Dali::Vector4 *)jarg2;
5390   if (!arg2) {
5391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5392     return 0;
5393   }
5394   {
5395     try {
5396       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5397     } catch (std::out_of_range& e) {
5398       {
5399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5400       };
5401     } catch (std::exception& e) {
5402       {
5403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5404       };
5405     } catch (...) {
5406       {
5407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5408       };
5409     }
5410   }
5411   jresult = (void *)result;
5412   return jresult;
5413 }
5414
5415
5416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5417   void * jresult ;
5418   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5419   Dali::Vector3 *arg2 = 0 ;
5420   Dali::Vector3 result;
5421
5422   arg1 = (Dali::Vector3 *)jarg1;
5423   arg2 = (Dali::Vector3 *)jarg2;
5424   if (!arg2) {
5425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5426     return 0;
5427   }
5428   {
5429     try {
5430       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5431     } catch (std::out_of_range& e) {
5432       {
5433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5434       };
5435     } catch (std::exception& e) {
5436       {
5437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5438       };
5439     } catch (...) {
5440       {
5441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5442       };
5443     }
5444   }
5445   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5446   return jresult;
5447 }
5448
5449
5450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5451   void * jresult ;
5452   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5453   Dali::Vector3 *arg2 = 0 ;
5454   Dali::Vector3 *result = 0 ;
5455
5456   arg1 = (Dali::Vector3 *)jarg1;
5457   arg2 = (Dali::Vector3 *)jarg2;
5458   if (!arg2) {
5459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5460     return 0;
5461   }
5462   {
5463     try {
5464       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
5465     } catch (std::out_of_range& e) {
5466       {
5467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5468       };
5469     } catch (std::exception& e) {
5470       {
5471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5472       };
5473     } catch (...) {
5474       {
5475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5476       };
5477     }
5478   }
5479   jresult = (void *)result;
5480   return jresult;
5481 }
5482
5483
5484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5485   void * jresult ;
5486   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5487   Dali::Vector3 *arg2 = 0 ;
5488   Dali::Vector3 result;
5489
5490   arg1 = (Dali::Vector3 *)jarg1;
5491   arg2 = (Dali::Vector3 *)jarg2;
5492   if (!arg2) {
5493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5494     return 0;
5495   }
5496   {
5497     try {
5498       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
5499     } catch (std::out_of_range& e) {
5500       {
5501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5502       };
5503     } catch (std::exception& e) {
5504       {
5505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5506       };
5507     } catch (...) {
5508       {
5509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5510       };
5511     }
5512   }
5513   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5514   return jresult;
5515 }
5516
5517
5518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
5519   void * jresult ;
5520   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5521   Dali::Vector3 *arg2 = 0 ;
5522   Dali::Vector3 *result = 0 ;
5523
5524   arg1 = (Dali::Vector3 *)jarg1;
5525   arg2 = (Dali::Vector3 *)jarg2;
5526   if (!arg2) {
5527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5528     return 0;
5529   }
5530   {
5531     try {
5532       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
5533     } catch (std::out_of_range& e) {
5534       {
5535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5536       };
5537     } catch (std::exception& e) {
5538       {
5539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5540       };
5541     } catch (...) {
5542       {
5543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5544       };
5545     }
5546   }
5547   jresult = (void *)result;
5548   return jresult;
5549 }
5550
5551
5552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
5553   void * jresult ;
5554   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5555   Dali::Vector3 *arg2 = 0 ;
5556   Dali::Vector3 result;
5557
5558   arg1 = (Dali::Vector3 *)jarg1;
5559   arg2 = (Dali::Vector3 *)jarg2;
5560   if (!arg2) {
5561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5562     return 0;
5563   }
5564   {
5565     try {
5566       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
5567     } catch (std::out_of_range& e) {
5568       {
5569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5570       };
5571     } catch (std::exception& e) {
5572       {
5573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5574       };
5575     } catch (...) {
5576       {
5577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5578       };
5579     }
5580   }
5581   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5582   return jresult;
5583 }
5584
5585
5586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
5587   void * jresult ;
5588   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5589   float arg2 ;
5590   Dali::Vector3 result;
5591
5592   arg1 = (Dali::Vector3 *)jarg1;
5593   arg2 = (float)jarg2;
5594   {
5595     try {
5596       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
5597     } catch (std::out_of_range& e) {
5598       {
5599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5600       };
5601     } catch (std::exception& e) {
5602       {
5603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5604       };
5605     } catch (...) {
5606       {
5607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5608       };
5609     }
5610   }
5611   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5612   return jresult;
5613 }
5614
5615
5616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
5617   void * jresult ;
5618   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5619   Dali::Vector3 *arg2 = 0 ;
5620   Dali::Vector3 *result = 0 ;
5621
5622   arg1 = (Dali::Vector3 *)jarg1;
5623   arg2 = (Dali::Vector3 *)jarg2;
5624   if (!arg2) {
5625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5626     return 0;
5627   }
5628   {
5629     try {
5630       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
5631     } catch (std::out_of_range& e) {
5632       {
5633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5634       };
5635     } catch (std::exception& e) {
5636       {
5637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5638       };
5639     } catch (...) {
5640       {
5641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5642       };
5643     }
5644   }
5645   jresult = (void *)result;
5646   return jresult;
5647 }
5648
5649
5650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
5651   void * jresult ;
5652   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5653   float arg2 ;
5654   Dali::Vector3 *result = 0 ;
5655
5656   arg1 = (Dali::Vector3 *)jarg1;
5657   arg2 = (float)jarg2;
5658   {
5659     try {
5660       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
5661     } catch (std::out_of_range& e) {
5662       {
5663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5664       };
5665     } catch (std::exception& e) {
5666       {
5667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5668       };
5669     } catch (...) {
5670       {
5671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5672       };
5673     }
5674   }
5675   jresult = (void *)result;
5676   return jresult;
5677 }
5678
5679
5680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
5681   void * jresult ;
5682   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5683   Dali::Quaternion *arg2 = 0 ;
5684   Dali::Vector3 *result = 0 ;
5685
5686   arg1 = (Dali::Vector3 *)jarg1;
5687   arg2 = (Dali::Quaternion *)jarg2;
5688   if (!arg2) {
5689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
5690     return 0;
5691   }
5692   {
5693     try {
5694       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
5695     } catch (std::out_of_range& e) {
5696       {
5697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5698       };
5699     } catch (std::exception& e) {
5700       {
5701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5702       };
5703     } catch (...) {
5704       {
5705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5706       };
5707     }
5708   }
5709   jresult = (void *)result;
5710   return jresult;
5711 }
5712
5713
5714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
5715   void * jresult ;
5716   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5717   Dali::Vector3 *arg2 = 0 ;
5718   Dali::Vector3 result;
5719
5720   arg1 = (Dali::Vector3 *)jarg1;
5721   arg2 = (Dali::Vector3 *)jarg2;
5722   if (!arg2) {
5723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5724     return 0;
5725   }
5726   {
5727     try {
5728       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
5729     } catch (std::out_of_range& e) {
5730       {
5731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5732       };
5733     } catch (std::exception& e) {
5734       {
5735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5736       };
5737     } catch (...) {
5738       {
5739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5740       };
5741     }
5742   }
5743   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5744   return jresult;
5745 }
5746
5747
5748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
5749   void * jresult ;
5750   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5751   float arg2 ;
5752   Dali::Vector3 result;
5753
5754   arg1 = (Dali::Vector3 *)jarg1;
5755   arg2 = (float)jarg2;
5756   {
5757     try {
5758       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
5759     } catch (std::out_of_range& e) {
5760       {
5761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5762       };
5763     } catch (std::exception& e) {
5764       {
5765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5766       };
5767     } catch (...) {
5768       {
5769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5770       };
5771     }
5772   }
5773   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5774   return jresult;
5775 }
5776
5777
5778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
5779   void * jresult ;
5780   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5781   Dali::Vector3 *arg2 = 0 ;
5782   Dali::Vector3 *result = 0 ;
5783
5784   arg1 = (Dali::Vector3 *)jarg1;
5785   arg2 = (Dali::Vector3 *)jarg2;
5786   if (!arg2) {
5787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5788     return 0;
5789   }
5790   {
5791     try {
5792       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
5793     } catch (std::out_of_range& e) {
5794       {
5795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5796       };
5797     } catch (std::exception& e) {
5798       {
5799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5800       };
5801     } catch (...) {
5802       {
5803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5804       };
5805     }
5806   }
5807   jresult = (void *)result;
5808   return jresult;
5809 }
5810
5811
5812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
5813   void * jresult ;
5814   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5815   float arg2 ;
5816   Dali::Vector3 *result = 0 ;
5817
5818   arg1 = (Dali::Vector3 *)jarg1;
5819   arg2 = (float)jarg2;
5820   {
5821     try {
5822       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
5823     } catch (std::out_of_range& e) {
5824       {
5825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5826       };
5827     } catch (std::exception& e) {
5828       {
5829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5830       };
5831     } catch (...) {
5832       {
5833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5834       };
5835     }
5836   }
5837   jresult = (void *)result;
5838   return jresult;
5839 }
5840
5841
5842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
5843   void * jresult ;
5844   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5845   Dali::Vector3 result;
5846
5847   arg1 = (Dali::Vector3 *)jarg1;
5848   {
5849     try {
5850       result = ((Dali::Vector3 const *)arg1)->operator -();
5851     } catch (std::out_of_range& e) {
5852       {
5853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5854       };
5855     } catch (std::exception& e) {
5856       {
5857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5858       };
5859     } catch (...) {
5860       {
5861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5862       };
5863     }
5864   }
5865   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5866   return jresult;
5867 }
5868
5869
5870 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
5871   unsigned int jresult ;
5872   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5873   Dali::Vector3 *arg2 = 0 ;
5874   bool result;
5875
5876   arg1 = (Dali::Vector3 *)jarg1;
5877   arg2 = (Dali::Vector3 *)jarg2;
5878   if (!arg2) {
5879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5880     return 0;
5881   }
5882   {
5883     try {
5884       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
5885     } catch (std::out_of_range& e) {
5886       {
5887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5888       };
5889     } catch (std::exception& e) {
5890       {
5891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5892       };
5893     } catch (...) {
5894       {
5895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5896       };
5897     }
5898   }
5899   jresult = result;
5900   return jresult;
5901 }
5902
5903
5904 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
5905   unsigned int jresult ;
5906   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5907   Dali::Vector3 *arg2 = 0 ;
5908   bool result;
5909
5910   arg1 = (Dali::Vector3 *)jarg1;
5911   arg2 = (Dali::Vector3 *)jarg2;
5912   if (!arg2) {
5913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5914     return 0;
5915   }
5916   {
5917     try {
5918       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
5919     } catch (std::out_of_range& e) {
5920       {
5921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5922       };
5923     } catch (std::exception& e) {
5924       {
5925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5926       };
5927     } catch (...) {
5928       {
5929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5930       };
5931     }
5932   }
5933   jresult = result;
5934   return jresult;
5935 }
5936
5937
5938 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5939   float jresult ;
5940   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5941   unsigned int arg2 ;
5942   float *result = 0 ;
5943
5944   arg1 = (Dali::Vector3 *)jarg1;
5945   arg2 = (unsigned int)jarg2;
5946   {
5947     try {
5948       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
5949     } catch (std::out_of_range& e) {
5950       {
5951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5952       };
5953     } catch (std::exception& e) {
5954       {
5955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5956       };
5957     } catch (...) {
5958       {
5959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5960       };
5961     }
5962   }
5963   jresult = *result;
5964   return jresult;
5965 }
5966
5967
5968 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
5969   float jresult ;
5970   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5971   Dali::Vector3 *arg2 = 0 ;
5972   float result;
5973
5974   arg1 = (Dali::Vector3 *)jarg1;
5975   arg2 = (Dali::Vector3 *)jarg2;
5976   if (!arg2) {
5977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5978     return 0;
5979   }
5980   {
5981     try {
5982       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
5983     } catch (std::out_of_range& e) {
5984       {
5985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5986       };
5987     } catch (std::exception& e) {
5988       {
5989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5990       };
5991     } catch (...) {
5992       {
5993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5994       };
5995     }
5996   }
5997   jresult = result;
5998   return jresult;
5999 }
6000
6001
6002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6003   void * jresult ;
6004   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6005   Dali::Vector3 *arg2 = 0 ;
6006   Dali::Vector3 result;
6007
6008   arg1 = (Dali::Vector3 *)jarg1;
6009   arg2 = (Dali::Vector3 *)jarg2;
6010   if (!arg2) {
6011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6012     return 0;
6013   }
6014   {
6015     try {
6016       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6017     } catch (std::out_of_range& e) {
6018       {
6019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6020       };
6021     } catch (std::exception& e) {
6022       {
6023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6024       };
6025     } catch (...) {
6026       {
6027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6028       };
6029     }
6030   }
6031   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6032   return jresult;
6033 }
6034
6035
6036 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6037   float jresult ;
6038   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6039   float result;
6040
6041   arg1 = (Dali::Vector3 *)jarg1;
6042   {
6043     try {
6044       result = (float)((Dali::Vector3 const *)arg1)->Length();
6045     } catch (std::out_of_range& e) {
6046       {
6047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6048       };
6049     } catch (std::exception& e) {
6050       {
6051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6052       };
6053     } catch (...) {
6054       {
6055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6056       };
6057     }
6058   }
6059   jresult = result;
6060   return jresult;
6061 }
6062
6063
6064 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6065   float jresult ;
6066   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6067   float result;
6068
6069   arg1 = (Dali::Vector3 *)jarg1;
6070   {
6071     try {
6072       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6073     } catch (std::out_of_range& e) {
6074       {
6075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6076       };
6077     } catch (std::exception& e) {
6078       {
6079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6080       };
6081     } catch (...) {
6082       {
6083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6084       };
6085     }
6086   }
6087   jresult = result;
6088   return jresult;
6089 }
6090
6091
6092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6093   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6094
6095   arg1 = (Dali::Vector3 *)jarg1;
6096   {
6097     try {
6098       (arg1)->Normalize();
6099     } catch (std::out_of_range& e) {
6100       {
6101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6102       };
6103     } catch (std::exception& e) {
6104       {
6105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6106       };
6107     } catch (...) {
6108       {
6109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6110       };
6111     }
6112   }
6113 }
6114
6115
6116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6117   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6118   Dali::Vector3 *arg2 = 0 ;
6119   Dali::Vector3 *arg3 = 0 ;
6120
6121   arg1 = (Dali::Vector3 *)jarg1;
6122   arg2 = (Dali::Vector3 *)jarg2;
6123   if (!arg2) {
6124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6125     return ;
6126   }
6127   arg3 = (Dali::Vector3 *)jarg3;
6128   if (!arg3) {
6129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6130     return ;
6131   }
6132   {
6133     try {
6134       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6135     } catch (std::out_of_range& e) {
6136       {
6137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6138       };
6139     } catch (std::exception& e) {
6140       {
6141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6142       };
6143     } catch (...) {
6144       {
6145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6146       };
6147     }
6148   }
6149 }
6150
6151
6152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6153   void * jresult ;
6154   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6155   float *result = 0 ;
6156
6157   arg1 = (Dali::Vector3 *)jarg1;
6158   {
6159     try {
6160       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6161     } catch (std::out_of_range& e) {
6162       {
6163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6164       };
6165     } catch (std::exception& e) {
6166       {
6167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6168       };
6169     } catch (...) {
6170       {
6171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6172       };
6173     }
6174   }
6175   jresult = (void *)result;
6176   return jresult;
6177 }
6178
6179
6180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6181   void * jresult ;
6182   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6183   Dali::Vector2 *result = 0 ;
6184
6185   arg1 = (Dali::Vector3 *)jarg1;
6186   {
6187     try {
6188       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6189     } catch (std::out_of_range& e) {
6190       {
6191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6192       };
6193     } catch (std::exception& e) {
6194       {
6195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6196       };
6197     } catch (...) {
6198       {
6199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6200       };
6201     }
6202   }
6203   jresult = (void *)result;
6204   return jresult;
6205 }
6206
6207
6208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6209   void * jresult ;
6210   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6211   Dali::Vector2 *result = 0 ;
6212
6213   arg1 = (Dali::Vector3 *)jarg1;
6214   {
6215     try {
6216       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6217     } catch (std::out_of_range& e) {
6218       {
6219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6220       };
6221     } catch (std::exception& e) {
6222       {
6223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6224       };
6225     } catch (...) {
6226       {
6227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6228       };
6229     }
6230   }
6231   jresult = (void *)result;
6232   return jresult;
6233 }
6234
6235
6236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6237   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6238   float arg2 ;
6239
6240   arg1 = (Dali::Vector3 *)jarg1;
6241   arg2 = (float)jarg2;
6242   if (arg1) (arg1)->x = arg2;
6243 }
6244
6245
6246 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6247   float jresult ;
6248   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6249   float result;
6250
6251   arg1 = (Dali::Vector3 *)jarg1;
6252   result = (float) ((arg1)->x);
6253   jresult = result;
6254   return jresult;
6255 }
6256
6257
6258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6259   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6260   float arg2 ;
6261
6262   arg1 = (Dali::Vector3 *)jarg1;
6263   arg2 = (float)jarg2;
6264   if (arg1) (arg1)->width = arg2;
6265 }
6266
6267
6268 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6269   float jresult ;
6270   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6271   float result;
6272
6273   arg1 = (Dali::Vector3 *)jarg1;
6274   result = (float) ((arg1)->width);
6275   jresult = result;
6276   return jresult;
6277 }
6278
6279
6280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6281   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6282   float arg2 ;
6283
6284   arg1 = (Dali::Vector3 *)jarg1;
6285   arg2 = (float)jarg2;
6286   if (arg1) (arg1)->r = arg2;
6287 }
6288
6289
6290 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6291   float jresult ;
6292   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6293   float result;
6294
6295   arg1 = (Dali::Vector3 *)jarg1;
6296   result = (float) ((arg1)->r);
6297   jresult = result;
6298   return jresult;
6299 }
6300
6301
6302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6303   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6304   float arg2 ;
6305
6306   arg1 = (Dali::Vector3 *)jarg1;
6307   arg2 = (float)jarg2;
6308   if (arg1) (arg1)->y = arg2;
6309 }
6310
6311
6312 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6313   float jresult ;
6314   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6315   float result;
6316
6317   arg1 = (Dali::Vector3 *)jarg1;
6318   result = (float) ((arg1)->y);
6319   jresult = result;
6320   return jresult;
6321 }
6322
6323
6324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6325   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6326   float arg2 ;
6327
6328   arg1 = (Dali::Vector3 *)jarg1;
6329   arg2 = (float)jarg2;
6330   if (arg1) (arg1)->height = arg2;
6331 }
6332
6333
6334 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
6335   float jresult ;
6336   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6337   float result;
6338
6339   arg1 = (Dali::Vector3 *)jarg1;
6340   result = (float) ((arg1)->height);
6341   jresult = result;
6342   return jresult;
6343 }
6344
6345
6346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
6347   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6348   float arg2 ;
6349
6350   arg1 = (Dali::Vector3 *)jarg1;
6351   arg2 = (float)jarg2;
6352   if (arg1) (arg1)->g = arg2;
6353 }
6354
6355
6356 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
6357   float jresult ;
6358   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6359   float result;
6360
6361   arg1 = (Dali::Vector3 *)jarg1;
6362   result = (float) ((arg1)->g);
6363   jresult = result;
6364   return jresult;
6365 }
6366
6367
6368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
6369   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6370   float arg2 ;
6371
6372   arg1 = (Dali::Vector3 *)jarg1;
6373   arg2 = (float)jarg2;
6374   if (arg1) (arg1)->z = arg2;
6375 }
6376
6377
6378 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
6379   float jresult ;
6380   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6381   float result;
6382
6383   arg1 = (Dali::Vector3 *)jarg1;
6384   result = (float) ((arg1)->z);
6385   jresult = result;
6386   return jresult;
6387 }
6388
6389
6390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
6391   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6392   float arg2 ;
6393
6394   arg1 = (Dali::Vector3 *)jarg1;
6395   arg2 = (float)jarg2;
6396   if (arg1) (arg1)->depth = arg2;
6397 }
6398
6399
6400 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
6401   float jresult ;
6402   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6403   float result;
6404
6405   arg1 = (Dali::Vector3 *)jarg1;
6406   result = (float) ((arg1)->depth);
6407   jresult = result;
6408   return jresult;
6409 }
6410
6411
6412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
6413   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6414   float arg2 ;
6415
6416   arg1 = (Dali::Vector3 *)jarg1;
6417   arg2 = (float)jarg2;
6418   if (arg1) (arg1)->b = arg2;
6419 }
6420
6421
6422 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
6423   float jresult ;
6424   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6425   float result;
6426
6427   arg1 = (Dali::Vector3 *)jarg1;
6428   result = (float) ((arg1)->b);
6429   jresult = result;
6430   return jresult;
6431 }
6432
6433
6434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
6435   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6436
6437   arg1 = (Dali::Vector3 *)jarg1;
6438   {
6439     try {
6440       delete arg1;
6441     } catch (std::out_of_range& e) {
6442       {
6443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6444       };
6445     } catch (std::exception& e) {
6446       {
6447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6448       };
6449     } catch (...) {
6450       {
6451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6452       };
6453     }
6454   }
6455 }
6456
6457
6458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
6459   void * jresult ;
6460   Dali::Vector3 *arg1 = 0 ;
6461   Dali::Vector3 *arg2 = 0 ;
6462   Dali::Vector3 result;
6463
6464   arg1 = (Dali::Vector3 *)jarg1;
6465   if (!arg1) {
6466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6467     return 0;
6468   }
6469   arg2 = (Dali::Vector3 *)jarg2;
6470   if (!arg2) {
6471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6472     return 0;
6473   }
6474   {
6475     try {
6476       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6477     } catch (std::out_of_range& e) {
6478       {
6479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6480       };
6481     } catch (std::exception& e) {
6482       {
6483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6484       };
6485     } catch (...) {
6486       {
6487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6488       };
6489     }
6490   }
6491   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6492   return jresult;
6493 }
6494
6495
6496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
6497   void * jresult ;
6498   Dali::Vector3 *arg1 = 0 ;
6499   Dali::Vector3 *arg2 = 0 ;
6500   Dali::Vector3 result;
6501
6502   arg1 = (Dali::Vector3 *)jarg1;
6503   if (!arg1) {
6504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6505     return 0;
6506   }
6507   arg2 = (Dali::Vector3 *)jarg2;
6508   if (!arg2) {
6509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6510     return 0;
6511   }
6512   {
6513     try {
6514       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6515     } catch (std::out_of_range& e) {
6516       {
6517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6518       };
6519     } catch (std::exception& e) {
6520       {
6521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6522       };
6523     } catch (...) {
6524       {
6525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6526       };
6527     }
6528   }
6529   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6530   return jresult;
6531 }
6532
6533
6534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
6535   void * jresult ;
6536   Dali::Vector3 *arg1 = 0 ;
6537   float *arg2 = 0 ;
6538   float *arg3 = 0 ;
6539   float temp2 ;
6540   float temp3 ;
6541   Dali::Vector3 result;
6542
6543   arg1 = (Dali::Vector3 *)jarg1;
6544   if (!arg1) {
6545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6546     return 0;
6547   }
6548   temp2 = (float)jarg2;
6549   arg2 = &temp2;
6550   temp3 = (float)jarg3;
6551   arg3 = &temp3;
6552   {
6553     try {
6554       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
6555     } catch (std::out_of_range& e) {
6556       {
6557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6558       };
6559     } catch (std::exception& e) {
6560       {
6561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6562       };
6563     } catch (...) {
6564       {
6565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6566       };
6567     }
6568   }
6569   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6570   return jresult;
6571 }
6572
6573
6574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
6575   void * jresult ;
6576   Dali::Vector4 *result = 0 ;
6577
6578   {
6579     try {
6580       result = (Dali::Vector4 *)new Dali::Vector4();
6581     } catch (std::out_of_range& e) {
6582       {
6583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6584       };
6585     } catch (std::exception& e) {
6586       {
6587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6588       };
6589     } catch (...) {
6590       {
6591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6592       };
6593     }
6594   }
6595   jresult = (void *)result;
6596   return jresult;
6597 }
6598
6599
6600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
6601   void * jresult ;
6602   float arg1 ;
6603   float arg2 ;
6604   float arg3 ;
6605   float arg4 ;
6606   Dali::Vector4 *result = 0 ;
6607
6608   arg1 = (float)jarg1;
6609   arg2 = (float)jarg2;
6610   arg3 = (float)jarg3;
6611   arg4 = (float)jarg4;
6612   {
6613     try {
6614       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
6615     } catch (std::out_of_range& e) {
6616       {
6617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6618       };
6619     } catch (std::exception& e) {
6620       {
6621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6622       };
6623     } catch (...) {
6624       {
6625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6626       };
6627     }
6628   }
6629   jresult = (void *)result;
6630   return jresult;
6631 }
6632
6633
6634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
6635   void * jresult ;
6636   float *arg1 = (float *) 0 ;
6637   Dali::Vector4 *result = 0 ;
6638
6639   arg1 = jarg1;
6640   {
6641     try {
6642       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
6643     } catch (std::out_of_range& e) {
6644       {
6645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6646       };
6647     } catch (std::exception& e) {
6648       {
6649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6650       };
6651     } catch (...) {
6652       {
6653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6654       };
6655     }
6656   }
6657   jresult = (void *)result;
6658
6659
6660   return jresult;
6661 }
6662
6663
6664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
6665   void * jresult ;
6666   Dali::Vector2 *arg1 = 0 ;
6667   Dali::Vector4 *result = 0 ;
6668
6669   arg1 = (Dali::Vector2 *)jarg1;
6670   if (!arg1) {
6671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6672     return 0;
6673   }
6674   {
6675     try {
6676       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
6677     } catch (std::out_of_range& e) {
6678       {
6679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6680       };
6681     } catch (std::exception& e) {
6682       {
6683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6684       };
6685     } catch (...) {
6686       {
6687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6688       };
6689     }
6690   }
6691   jresult = (void *)result;
6692   return jresult;
6693 }
6694
6695
6696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
6697   void * jresult ;
6698   Dali::Vector3 *arg1 = 0 ;
6699   Dali::Vector4 *result = 0 ;
6700
6701   arg1 = (Dali::Vector3 *)jarg1;
6702   if (!arg1) {
6703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6704     return 0;
6705   }
6706   {
6707     try {
6708       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
6709     } catch (std::out_of_range& e) {
6710       {
6711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6712       };
6713     } catch (std::exception& e) {
6714       {
6715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6716       };
6717     } catch (...) {
6718       {
6719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6720       };
6721     }
6722   }
6723   jresult = (void *)result;
6724   return jresult;
6725 }
6726
6727
6728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
6729   void * jresult ;
6730   Dali::Vector4 *result = 0 ;
6731
6732   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
6733   jresult = (void *)result;
6734   return jresult;
6735 }
6736
6737
6738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
6739   void * jresult ;
6740   Dali::Vector4 *result = 0 ;
6741
6742   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
6743   jresult = (void *)result;
6744   return jresult;
6745 }
6746
6747
6748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
6749   void * jresult ;
6750   Dali::Vector4 *result = 0 ;
6751
6752   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
6753   jresult = (void *)result;
6754   return jresult;
6755 }
6756
6757
6758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
6759   void * jresult ;
6760   Dali::Vector4 *result = 0 ;
6761
6762   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
6763   jresult = (void *)result;
6764   return jresult;
6765 }
6766
6767
6768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
6769   void * jresult ;
6770   Dali::Vector4 *result = 0 ;
6771
6772   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
6773   jresult = (void *)result;
6774   return jresult;
6775 }
6776
6777
6778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
6779   void * jresult ;
6780   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6781   float *arg2 = (float *) 0 ;
6782   Dali::Vector4 *result = 0 ;
6783
6784   arg1 = (Dali::Vector4 *)jarg1;
6785   arg2 = jarg2;
6786   {
6787     try {
6788       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
6789     } catch (std::out_of_range& e) {
6790       {
6791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6792       };
6793     } catch (std::exception& e) {
6794       {
6795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6796       };
6797     } catch (...) {
6798       {
6799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6800       };
6801     }
6802   }
6803   jresult = (void *)result;
6804
6805
6806   return jresult;
6807 }
6808
6809
6810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
6811   void * jresult ;
6812   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6813   Dali::Vector2 *arg2 = 0 ;
6814   Dali::Vector4 *result = 0 ;
6815
6816   arg1 = (Dali::Vector4 *)jarg1;
6817   arg2 = (Dali::Vector2 *)jarg2;
6818   if (!arg2) {
6819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6820     return 0;
6821   }
6822   {
6823     try {
6824       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
6825     } catch (std::out_of_range& e) {
6826       {
6827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6828       };
6829     } catch (std::exception& e) {
6830       {
6831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6832       };
6833     } catch (...) {
6834       {
6835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6836       };
6837     }
6838   }
6839   jresult = (void *)result;
6840   return jresult;
6841 }
6842
6843
6844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
6845   void * jresult ;
6846   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6847   Dali::Vector3 *arg2 = 0 ;
6848   Dali::Vector4 *result = 0 ;
6849
6850   arg1 = (Dali::Vector4 *)jarg1;
6851   arg2 = (Dali::Vector3 *)jarg2;
6852   if (!arg2) {
6853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6854     return 0;
6855   }
6856   {
6857     try {
6858       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
6859     } catch (std::out_of_range& e) {
6860       {
6861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6862       };
6863     } catch (std::exception& e) {
6864       {
6865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6866       };
6867     } catch (...) {
6868       {
6869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6870       };
6871     }
6872   }
6873   jresult = (void *)result;
6874   return jresult;
6875 }
6876
6877
6878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
6879   void * jresult ;
6880   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6881   Dali::Vector4 *arg2 = 0 ;
6882   Dali::Vector4 result;
6883
6884   arg1 = (Dali::Vector4 *)jarg1;
6885   arg2 = (Dali::Vector4 *)jarg2;
6886   if (!arg2) {
6887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6888     return 0;
6889   }
6890   {
6891     try {
6892       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
6893     } catch (std::out_of_range& e) {
6894       {
6895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6896       };
6897     } catch (std::exception& e) {
6898       {
6899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6900       };
6901     } catch (...) {
6902       {
6903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6904       };
6905     }
6906   }
6907   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6908   return jresult;
6909 }
6910
6911
6912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
6913   void * jresult ;
6914   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6915   Dali::Vector4 *arg2 = 0 ;
6916   Dali::Vector4 *result = 0 ;
6917
6918   arg1 = (Dali::Vector4 *)jarg1;
6919   arg2 = (Dali::Vector4 *)jarg2;
6920   if (!arg2) {
6921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6922     return 0;
6923   }
6924   {
6925     try {
6926       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
6927     } catch (std::out_of_range& e) {
6928       {
6929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6930       };
6931     } catch (std::exception& e) {
6932       {
6933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6934       };
6935     } catch (...) {
6936       {
6937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6938       };
6939     }
6940   }
6941   jresult = (void *)result;
6942   return jresult;
6943 }
6944
6945
6946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6947   void * jresult ;
6948   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6949   Dali::Vector4 *arg2 = 0 ;
6950   Dali::Vector4 result;
6951
6952   arg1 = (Dali::Vector4 *)jarg1;
6953   arg2 = (Dali::Vector4 *)jarg2;
6954   if (!arg2) {
6955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6956     return 0;
6957   }
6958   {
6959     try {
6960       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
6961     } catch (std::out_of_range& e) {
6962       {
6963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6964       };
6965     } catch (std::exception& e) {
6966       {
6967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6968       };
6969     } catch (...) {
6970       {
6971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6972       };
6973     }
6974   }
6975   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6976   return jresult;
6977 }
6978
6979
6980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
6981   void * jresult ;
6982   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6983   Dali::Vector4 *arg2 = 0 ;
6984   Dali::Vector4 *result = 0 ;
6985
6986   arg1 = (Dali::Vector4 *)jarg1;
6987   arg2 = (Dali::Vector4 *)jarg2;
6988   if (!arg2) {
6989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6990     return 0;
6991   }
6992   {
6993     try {
6994       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
6995     } catch (std::out_of_range& e) {
6996       {
6997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6998       };
6999     } catch (std::exception& e) {
7000       {
7001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7002       };
7003     } catch (...) {
7004       {
7005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7006       };
7007     }
7008   }
7009   jresult = (void *)result;
7010   return jresult;
7011 }
7012
7013
7014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7015   void * jresult ;
7016   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7017   Dali::Vector4 *arg2 = 0 ;
7018   Dali::Vector4 result;
7019
7020   arg1 = (Dali::Vector4 *)jarg1;
7021   arg2 = (Dali::Vector4 *)jarg2;
7022   if (!arg2) {
7023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7024     return 0;
7025   }
7026   {
7027     try {
7028       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7029     } catch (std::out_of_range& e) {
7030       {
7031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7032       };
7033     } catch (std::exception& e) {
7034       {
7035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7036       };
7037     } catch (...) {
7038       {
7039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7040       };
7041     }
7042   }
7043   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7044   return jresult;
7045 }
7046
7047
7048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7049   void * jresult ;
7050   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7051   float arg2 ;
7052   Dali::Vector4 result;
7053
7054   arg1 = (Dali::Vector4 *)jarg1;
7055   arg2 = (float)jarg2;
7056   {
7057     try {
7058       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7059     } catch (std::out_of_range& e) {
7060       {
7061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7062       };
7063     } catch (std::exception& e) {
7064       {
7065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7066       };
7067     } catch (...) {
7068       {
7069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7070       };
7071     }
7072   }
7073   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7074   return jresult;
7075 }
7076
7077
7078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7079   void * jresult ;
7080   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7081   Dali::Vector4 *arg2 = 0 ;
7082   Dali::Vector4 *result = 0 ;
7083
7084   arg1 = (Dali::Vector4 *)jarg1;
7085   arg2 = (Dali::Vector4 *)jarg2;
7086   if (!arg2) {
7087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7088     return 0;
7089   }
7090   {
7091     try {
7092       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7093     } catch (std::out_of_range& e) {
7094       {
7095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7096       };
7097     } catch (std::exception& e) {
7098       {
7099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7100       };
7101     } catch (...) {
7102       {
7103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7104       };
7105     }
7106   }
7107   jresult = (void *)result;
7108   return jresult;
7109 }
7110
7111
7112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7113   void * jresult ;
7114   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7115   float arg2 ;
7116   Dali::Vector4 *result = 0 ;
7117
7118   arg1 = (Dali::Vector4 *)jarg1;
7119   arg2 = (float)jarg2;
7120   {
7121     try {
7122       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7123     } catch (std::out_of_range& e) {
7124       {
7125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7126       };
7127     } catch (std::exception& e) {
7128       {
7129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7130       };
7131     } catch (...) {
7132       {
7133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7134       };
7135     }
7136   }
7137   jresult = (void *)result;
7138   return jresult;
7139 }
7140
7141
7142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7143   void * jresult ;
7144   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7145   Dali::Vector4 *arg2 = 0 ;
7146   Dali::Vector4 result;
7147
7148   arg1 = (Dali::Vector4 *)jarg1;
7149   arg2 = (Dali::Vector4 *)jarg2;
7150   if (!arg2) {
7151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7152     return 0;
7153   }
7154   {
7155     try {
7156       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7157     } catch (std::out_of_range& e) {
7158       {
7159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7160       };
7161     } catch (std::exception& e) {
7162       {
7163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7164       };
7165     } catch (...) {
7166       {
7167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7168       };
7169     }
7170   }
7171   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7172   return jresult;
7173 }
7174
7175
7176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7177   void * jresult ;
7178   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7179   float arg2 ;
7180   Dali::Vector4 result;
7181
7182   arg1 = (Dali::Vector4 *)jarg1;
7183   arg2 = (float)jarg2;
7184   {
7185     try {
7186       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7187     } catch (std::out_of_range& e) {
7188       {
7189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7190       };
7191     } catch (std::exception& e) {
7192       {
7193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7194       };
7195     } catch (...) {
7196       {
7197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7198       };
7199     }
7200   }
7201   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7202   return jresult;
7203 }
7204
7205
7206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7207   void * jresult ;
7208   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7209   Dali::Vector4 *arg2 = 0 ;
7210   Dali::Vector4 *result = 0 ;
7211
7212   arg1 = (Dali::Vector4 *)jarg1;
7213   arg2 = (Dali::Vector4 *)jarg2;
7214   if (!arg2) {
7215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7216     return 0;
7217   }
7218   {
7219     try {
7220       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7221     } catch (std::out_of_range& e) {
7222       {
7223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7224       };
7225     } catch (std::exception& e) {
7226       {
7227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7228       };
7229     } catch (...) {
7230       {
7231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7232       };
7233     }
7234   }
7235   jresult = (void *)result;
7236   return jresult;
7237 }
7238
7239
7240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
7241   void * jresult ;
7242   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7243   float arg2 ;
7244   Dali::Vector4 *result = 0 ;
7245
7246   arg1 = (Dali::Vector4 *)jarg1;
7247   arg2 = (float)jarg2;
7248   {
7249     try {
7250       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
7251     } catch (std::out_of_range& e) {
7252       {
7253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7254       };
7255     } catch (std::exception& e) {
7256       {
7257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7258       };
7259     } catch (...) {
7260       {
7261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7262       };
7263     }
7264   }
7265   jresult = (void *)result;
7266   return jresult;
7267 }
7268
7269
7270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
7271   void * jresult ;
7272   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7273   Dali::Vector4 result;
7274
7275   arg1 = (Dali::Vector4 *)jarg1;
7276   {
7277     try {
7278       result = ((Dali::Vector4 const *)arg1)->operator -();
7279     } catch (std::out_of_range& e) {
7280       {
7281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7282       };
7283     } catch (std::exception& e) {
7284       {
7285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7286       };
7287     } catch (...) {
7288       {
7289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7290       };
7291     }
7292   }
7293   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7294   return jresult;
7295 }
7296
7297
7298 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
7299   unsigned int jresult ;
7300   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7301   Dali::Vector4 *arg2 = 0 ;
7302   bool result;
7303
7304   arg1 = (Dali::Vector4 *)jarg1;
7305   arg2 = (Dali::Vector4 *)jarg2;
7306   if (!arg2) {
7307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7308     return 0;
7309   }
7310   {
7311     try {
7312       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
7313     } catch (std::out_of_range& e) {
7314       {
7315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7316       };
7317     } catch (std::exception& e) {
7318       {
7319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7320       };
7321     } catch (...) {
7322       {
7323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7324       };
7325     }
7326   }
7327   jresult = result;
7328   return jresult;
7329 }
7330
7331
7332 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
7333   unsigned int jresult ;
7334   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7335   Dali::Vector4 *arg2 = 0 ;
7336   bool result;
7337
7338   arg1 = (Dali::Vector4 *)jarg1;
7339   arg2 = (Dali::Vector4 *)jarg2;
7340   if (!arg2) {
7341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7342     return 0;
7343   }
7344   {
7345     try {
7346       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
7347     } catch (std::out_of_range& e) {
7348       {
7349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7350       };
7351     } catch (std::exception& e) {
7352       {
7353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7354       };
7355     } catch (...) {
7356       {
7357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7358       };
7359     }
7360   }
7361   jresult = result;
7362   return jresult;
7363 }
7364
7365
7366 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
7367   float jresult ;
7368   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7369   unsigned int arg2 ;
7370   float *result = 0 ;
7371
7372   arg1 = (Dali::Vector4 *)jarg1;
7373   arg2 = (unsigned int)jarg2;
7374   {
7375     try {
7376       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
7377     } catch (std::out_of_range& e) {
7378       {
7379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7380       };
7381     } catch (std::exception& e) {
7382       {
7383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7384       };
7385     } catch (...) {
7386       {
7387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7388       };
7389     }
7390   }
7391   jresult = *result;
7392   return jresult;
7393 }
7394
7395
7396 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
7397   float jresult ;
7398   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7399   Dali::Vector3 *arg2 = 0 ;
7400   float result;
7401
7402   arg1 = (Dali::Vector4 *)jarg1;
7403   arg2 = (Dali::Vector3 *)jarg2;
7404   if (!arg2) {
7405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7406     return 0;
7407   }
7408   {
7409     try {
7410       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
7411     } catch (std::out_of_range& e) {
7412       {
7413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7414       };
7415     } catch (std::exception& e) {
7416       {
7417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7418       };
7419     } catch (...) {
7420       {
7421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7422       };
7423     }
7424   }
7425   jresult = result;
7426   return jresult;
7427 }
7428
7429
7430 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
7431   float jresult ;
7432   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7433   Dali::Vector4 *arg2 = 0 ;
7434   float result;
7435
7436   arg1 = (Dali::Vector4 *)jarg1;
7437   arg2 = (Dali::Vector4 *)jarg2;
7438   if (!arg2) {
7439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7440     return 0;
7441   }
7442   {
7443     try {
7444       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
7445     } catch (std::out_of_range& e) {
7446       {
7447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7448       };
7449     } catch (std::exception& e) {
7450       {
7451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7452       };
7453     } catch (...) {
7454       {
7455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7456       };
7457     }
7458   }
7459   jresult = result;
7460   return jresult;
7461 }
7462
7463
7464 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
7465   float jresult ;
7466   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7467   Dali::Vector4 *arg2 = 0 ;
7468   float result;
7469
7470   arg1 = (Dali::Vector4 *)jarg1;
7471   arg2 = (Dali::Vector4 *)jarg2;
7472   if (!arg2) {
7473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7474     return 0;
7475   }
7476   {
7477     try {
7478       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
7479     } catch (std::out_of_range& e) {
7480       {
7481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7482       };
7483     } catch (std::exception& e) {
7484       {
7485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7486       };
7487     } catch (...) {
7488       {
7489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7490       };
7491     }
7492   }
7493   jresult = result;
7494   return jresult;
7495 }
7496
7497
7498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
7499   void * jresult ;
7500   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7501   Dali::Vector4 *arg2 = 0 ;
7502   Dali::Vector4 result;
7503
7504   arg1 = (Dali::Vector4 *)jarg1;
7505   arg2 = (Dali::Vector4 *)jarg2;
7506   if (!arg2) {
7507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7508     return 0;
7509   }
7510   {
7511     try {
7512       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
7513     } catch (std::out_of_range& e) {
7514       {
7515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7516       };
7517     } catch (std::exception& e) {
7518       {
7519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7520       };
7521     } catch (...) {
7522       {
7523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7524       };
7525     }
7526   }
7527   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7528   return jresult;
7529 }
7530
7531
7532 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
7533   float jresult ;
7534   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7535   float result;
7536
7537   arg1 = (Dali::Vector4 *)jarg1;
7538   {
7539     try {
7540       result = (float)((Dali::Vector4 const *)arg1)->Length();
7541     } catch (std::out_of_range& e) {
7542       {
7543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7544       };
7545     } catch (std::exception& e) {
7546       {
7547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7548       };
7549     } catch (...) {
7550       {
7551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7552       };
7553     }
7554   }
7555   jresult = result;
7556   return jresult;
7557 }
7558
7559
7560 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
7561   float jresult ;
7562   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7563   float result;
7564
7565   arg1 = (Dali::Vector4 *)jarg1;
7566   {
7567     try {
7568       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
7569     } catch (std::out_of_range& e) {
7570       {
7571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7572       };
7573     } catch (std::exception& e) {
7574       {
7575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7576       };
7577     } catch (...) {
7578       {
7579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7580       };
7581     }
7582   }
7583   jresult = result;
7584   return jresult;
7585 }
7586
7587
7588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
7589   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7590
7591   arg1 = (Dali::Vector4 *)jarg1;
7592   {
7593     try {
7594       (arg1)->Normalize();
7595     } catch (std::out_of_range& e) {
7596       {
7597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7598       };
7599     } catch (std::exception& e) {
7600       {
7601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7602       };
7603     } catch (...) {
7604       {
7605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7606       };
7607     }
7608   }
7609 }
7610
7611
7612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
7613   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7614   Dali::Vector4 *arg2 = 0 ;
7615   Dali::Vector4 *arg3 = 0 ;
7616
7617   arg1 = (Dali::Vector4 *)jarg1;
7618   arg2 = (Dali::Vector4 *)jarg2;
7619   if (!arg2) {
7620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7621     return ;
7622   }
7623   arg3 = (Dali::Vector4 *)jarg3;
7624   if (!arg3) {
7625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7626     return ;
7627   }
7628   {
7629     try {
7630       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
7631     } catch (std::out_of_range& e) {
7632       {
7633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7634       };
7635     } catch (std::exception& e) {
7636       {
7637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7638       };
7639     } catch (...) {
7640       {
7641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7642       };
7643     }
7644   }
7645 }
7646
7647
7648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
7649   void * jresult ;
7650   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7651   float *result = 0 ;
7652
7653   arg1 = (Dali::Vector4 *)jarg1;
7654   {
7655     try {
7656       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
7657     } catch (std::out_of_range& e) {
7658       {
7659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7660       };
7661     } catch (std::exception& e) {
7662       {
7663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7664       };
7665     } catch (...) {
7666       {
7667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7668       };
7669     }
7670   }
7671   jresult = (void *)result;
7672   return jresult;
7673 }
7674
7675
7676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
7677   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7678   float arg2 ;
7679
7680   arg1 = (Dali::Vector4 *)jarg1;
7681   arg2 = (float)jarg2;
7682   if (arg1) (arg1)->x = arg2;
7683 }
7684
7685
7686 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
7687   float jresult ;
7688   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7689   float result;
7690
7691   arg1 = (Dali::Vector4 *)jarg1;
7692   result = (float) ((arg1)->x);
7693   jresult = result;
7694   return jresult;
7695 }
7696
7697
7698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
7699   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7700   float arg2 ;
7701
7702   arg1 = (Dali::Vector4 *)jarg1;
7703   arg2 = (float)jarg2;
7704   if (arg1) (arg1)->r = arg2;
7705 }
7706
7707
7708 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
7709   float jresult ;
7710   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7711   float result;
7712
7713   arg1 = (Dali::Vector4 *)jarg1;
7714   result = (float) ((arg1)->r);
7715   jresult = result;
7716   return jresult;
7717 }
7718
7719
7720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
7721   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7722   float arg2 ;
7723
7724   arg1 = (Dali::Vector4 *)jarg1;
7725   arg2 = (float)jarg2;
7726   if (arg1) (arg1)->s = arg2;
7727 }
7728
7729
7730 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
7731   float jresult ;
7732   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7733   float result;
7734
7735   arg1 = (Dali::Vector4 *)jarg1;
7736   result = (float) ((arg1)->s);
7737   jresult = result;
7738   return jresult;
7739 }
7740
7741
7742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
7743   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7744   float arg2 ;
7745
7746   arg1 = (Dali::Vector4 *)jarg1;
7747   arg2 = (float)jarg2;
7748   if (arg1) (arg1)->y = arg2;
7749 }
7750
7751
7752 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
7753   float jresult ;
7754   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7755   float result;
7756
7757   arg1 = (Dali::Vector4 *)jarg1;
7758   result = (float) ((arg1)->y);
7759   jresult = result;
7760   return jresult;
7761 }
7762
7763
7764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
7765   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7766   float arg2 ;
7767
7768   arg1 = (Dali::Vector4 *)jarg1;
7769   arg2 = (float)jarg2;
7770   if (arg1) (arg1)->g = arg2;
7771 }
7772
7773
7774 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
7775   float jresult ;
7776   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7777   float result;
7778
7779   arg1 = (Dali::Vector4 *)jarg1;
7780   result = (float) ((arg1)->g);
7781   jresult = result;
7782   return jresult;
7783 }
7784
7785
7786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
7787   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7788   float arg2 ;
7789
7790   arg1 = (Dali::Vector4 *)jarg1;
7791   arg2 = (float)jarg2;
7792   if (arg1) (arg1)->t = arg2;
7793 }
7794
7795
7796 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
7797   float jresult ;
7798   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7799   float result;
7800
7801   arg1 = (Dali::Vector4 *)jarg1;
7802   result = (float) ((arg1)->t);
7803   jresult = result;
7804   return jresult;
7805 }
7806
7807
7808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
7809   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7810   float arg2 ;
7811
7812   arg1 = (Dali::Vector4 *)jarg1;
7813   arg2 = (float)jarg2;
7814   if (arg1) (arg1)->z = arg2;
7815 }
7816
7817
7818 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
7819   float jresult ;
7820   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7821   float result;
7822
7823   arg1 = (Dali::Vector4 *)jarg1;
7824   result = (float) ((arg1)->z);
7825   jresult = result;
7826   return jresult;
7827 }
7828
7829
7830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
7831   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7832   float arg2 ;
7833
7834   arg1 = (Dali::Vector4 *)jarg1;
7835   arg2 = (float)jarg2;
7836   if (arg1) (arg1)->b = arg2;
7837 }
7838
7839
7840 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
7841   float jresult ;
7842   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7843   float result;
7844
7845   arg1 = (Dali::Vector4 *)jarg1;
7846   result = (float) ((arg1)->b);
7847   jresult = result;
7848   return jresult;
7849 }
7850
7851
7852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
7853   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7854   float arg2 ;
7855
7856   arg1 = (Dali::Vector4 *)jarg1;
7857   arg2 = (float)jarg2;
7858   if (arg1) (arg1)->p = arg2;
7859 }
7860
7861
7862 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
7863   float jresult ;
7864   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7865   float result;
7866
7867   arg1 = (Dali::Vector4 *)jarg1;
7868   result = (float) ((arg1)->p);
7869   jresult = result;
7870   return jresult;
7871 }
7872
7873
7874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
7875   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7876   float arg2 ;
7877
7878   arg1 = (Dali::Vector4 *)jarg1;
7879   arg2 = (float)jarg2;
7880   if (arg1) (arg1)->w = arg2;
7881 }
7882
7883
7884 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
7885   float jresult ;
7886   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7887   float result;
7888
7889   arg1 = (Dali::Vector4 *)jarg1;
7890   result = (float) ((arg1)->w);
7891   jresult = result;
7892   return jresult;
7893 }
7894
7895
7896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
7897   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7898   float arg2 ;
7899
7900   arg1 = (Dali::Vector4 *)jarg1;
7901   arg2 = (float)jarg2;
7902   if (arg1) (arg1)->a = arg2;
7903 }
7904
7905
7906 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
7907   float jresult ;
7908   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7909   float result;
7910
7911   arg1 = (Dali::Vector4 *)jarg1;
7912   result = (float) ((arg1)->a);
7913   jresult = result;
7914   return jresult;
7915 }
7916
7917
7918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
7919   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7920   float arg2 ;
7921
7922   arg1 = (Dali::Vector4 *)jarg1;
7923   arg2 = (float)jarg2;
7924   if (arg1) (arg1)->q = arg2;
7925 }
7926
7927
7928 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
7929   float jresult ;
7930   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7931   float result;
7932
7933   arg1 = (Dali::Vector4 *)jarg1;
7934   result = (float) ((arg1)->q);
7935   jresult = result;
7936   return jresult;
7937 }
7938
7939
7940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
7941   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7942
7943   arg1 = (Dali::Vector4 *)jarg1;
7944   {
7945     try {
7946       delete arg1;
7947     } catch (std::out_of_range& e) {
7948       {
7949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7950       };
7951     } catch (std::exception& e) {
7952       {
7953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7954       };
7955     } catch (...) {
7956       {
7957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7958       };
7959     }
7960   }
7961 }
7962
7963
7964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
7965   void * jresult ;
7966   Dali::Vector4 *arg1 = 0 ;
7967   Dali::Vector4 *arg2 = 0 ;
7968   Dali::Vector4 result;
7969
7970   arg1 = (Dali::Vector4 *)jarg1;
7971   if (!arg1) {
7972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7973     return 0;
7974   }
7975   arg2 = (Dali::Vector4 *)jarg2;
7976   if (!arg2) {
7977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7978     return 0;
7979   }
7980   {
7981     try {
7982       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7983     } catch (std::out_of_range& e) {
7984       {
7985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7986       };
7987     } catch (std::exception& e) {
7988       {
7989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7990       };
7991     } catch (...) {
7992       {
7993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7994       };
7995     }
7996   }
7997   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7998   return jresult;
7999 }
8000
8001
8002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8003   void * jresult ;
8004   Dali::Vector4 *arg1 = 0 ;
8005   Dali::Vector4 *arg2 = 0 ;
8006   Dali::Vector4 result;
8007
8008   arg1 = (Dali::Vector4 *)jarg1;
8009   if (!arg1) {
8010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8011     return 0;
8012   }
8013   arg2 = (Dali::Vector4 *)jarg2;
8014   if (!arg2) {
8015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8016     return 0;
8017   }
8018   {
8019     try {
8020       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8021     } catch (std::out_of_range& e) {
8022       {
8023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8024       };
8025     } catch (std::exception& e) {
8026       {
8027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8028       };
8029     } catch (...) {
8030       {
8031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8032       };
8033     }
8034   }
8035   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8036   return jresult;
8037 }
8038
8039
8040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8041   void * jresult ;
8042   Dali::Vector4 *arg1 = 0 ;
8043   float *arg2 = 0 ;
8044   float *arg3 = 0 ;
8045   float temp2 ;
8046   float temp3 ;
8047   Dali::Vector4 result;
8048
8049   arg1 = (Dali::Vector4 *)jarg1;
8050   if (!arg1) {
8051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8052     return 0;
8053   }
8054   temp2 = (float)jarg2;
8055   arg2 = &temp2;
8056   temp3 = (float)jarg3;
8057   arg3 = &temp3;
8058   {
8059     try {
8060       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8061     } catch (std::out_of_range& e) {
8062       {
8063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8064       };
8065     } catch (std::exception& e) {
8066       {
8067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8068       };
8069     } catch (...) {
8070       {
8071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8072       };
8073     }
8074   }
8075   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8076   return jresult;
8077 }
8078
8079
8080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8081   void * jresult ;
8082   Dali::Uint16Pair *result = 0 ;
8083
8084   {
8085     try {
8086       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8087     } catch (std::out_of_range& e) {
8088       {
8089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8090       };
8091     } catch (std::exception& e) {
8092       {
8093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8094       };
8095     } catch (...) {
8096       {
8097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8098       };
8099     }
8100   }
8101   jresult = (void *)result;
8102   return jresult;
8103 }
8104
8105
8106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8107   void * jresult ;
8108   uint32_t arg1 ;
8109   uint32_t arg2 ;
8110   Dali::Uint16Pair *result = 0 ;
8111
8112   arg1 = (uint32_t)jarg1;
8113   arg2 = (uint32_t)jarg2;
8114   {
8115     try {
8116       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8117     } catch (std::out_of_range& e) {
8118       {
8119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8120       };
8121     } catch (std::exception& e) {
8122       {
8123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8124       };
8125     } catch (...) {
8126       {
8127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8128       };
8129     }
8130   }
8131   jresult = (void *)result;
8132   return jresult;
8133 }
8134
8135
8136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
8137   void * jresult ;
8138   Dali::Uint16Pair *arg1 = 0 ;
8139   Dali::Uint16Pair *result = 0 ;
8140
8141   arg1 = (Dali::Uint16Pair *)jarg1;
8142   if (!arg1) {
8143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8144     return 0;
8145   }
8146   {
8147     try {
8148       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
8149     } catch (std::out_of_range& e) {
8150       {
8151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8152       };
8153     } catch (std::exception& e) {
8154       {
8155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8156       };
8157     } catch (...) {
8158       {
8159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8160       };
8161     }
8162   }
8163   jresult = (void *)result;
8164   return jresult;
8165 }
8166
8167
8168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
8169   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8170   uint16_t arg2 ;
8171
8172   arg1 = (Dali::Uint16Pair *)jarg1;
8173   arg2 = (uint16_t)jarg2;
8174   {
8175     try {
8176       (arg1)->SetWidth(arg2);
8177     } catch (std::out_of_range& e) {
8178       {
8179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8180       };
8181     } catch (std::exception& e) {
8182       {
8183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8184       };
8185     } catch (...) {
8186       {
8187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8188       };
8189     }
8190   }
8191 }
8192
8193
8194 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
8195   unsigned short jresult ;
8196   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8197   uint16_t result;
8198
8199   arg1 = (Dali::Uint16Pair *)jarg1;
8200   {
8201     try {
8202       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
8203     } catch (std::out_of_range& e) {
8204       {
8205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8206       };
8207     } catch (std::exception& e) {
8208       {
8209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8210       };
8211     } catch (...) {
8212       {
8213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8214       };
8215     }
8216   }
8217   jresult = result;
8218   return jresult;
8219 }
8220
8221
8222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
8223   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8224   uint16_t arg2 ;
8225
8226   arg1 = (Dali::Uint16Pair *)jarg1;
8227   arg2 = (uint16_t)jarg2;
8228   {
8229     try {
8230       (arg1)->SetHeight(arg2);
8231     } catch (std::out_of_range& e) {
8232       {
8233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8234       };
8235     } catch (std::exception& e) {
8236       {
8237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8238       };
8239     } catch (...) {
8240       {
8241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8242       };
8243     }
8244   }
8245 }
8246
8247
8248 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
8249   unsigned short jresult ;
8250   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8251   uint16_t result;
8252
8253   arg1 = (Dali::Uint16Pair *)jarg1;
8254   {
8255     try {
8256       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
8257     } catch (std::out_of_range& e) {
8258       {
8259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8260       };
8261     } catch (std::exception& e) {
8262       {
8263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8264       };
8265     } catch (...) {
8266       {
8267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8268       };
8269     }
8270   }
8271   jresult = result;
8272   return jresult;
8273 }
8274
8275
8276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
8277   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8278   uint16_t arg2 ;
8279
8280   arg1 = (Dali::Uint16Pair *)jarg1;
8281   arg2 = (uint16_t)jarg2;
8282   {
8283     try {
8284       (arg1)->SetX(arg2);
8285     } catch (std::out_of_range& e) {
8286       {
8287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8288       };
8289     } catch (std::exception& e) {
8290       {
8291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8292       };
8293     } catch (...) {
8294       {
8295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8296       };
8297     }
8298   }
8299 }
8300
8301
8302 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
8303   unsigned short jresult ;
8304   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8305   uint16_t result;
8306
8307   arg1 = (Dali::Uint16Pair *)jarg1;
8308   {
8309     try {
8310       result = ((Dali::Uint16Pair const *)arg1)->GetX();
8311     } catch (std::out_of_range& e) {
8312       {
8313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8314       };
8315     } catch (std::exception& e) {
8316       {
8317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8318       };
8319     } catch (...) {
8320       {
8321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8322       };
8323     }
8324   }
8325   jresult = result;
8326   return jresult;
8327 }
8328
8329
8330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
8331   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8332   uint16_t arg2 ;
8333
8334   arg1 = (Dali::Uint16Pair *)jarg1;
8335   arg2 = (uint16_t)jarg2;
8336   {
8337     try {
8338       (arg1)->SetY(arg2);
8339     } catch (std::out_of_range& e) {
8340       {
8341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8342       };
8343     } catch (std::exception& e) {
8344       {
8345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8346       };
8347     } catch (...) {
8348       {
8349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8350       };
8351     }
8352   }
8353 }
8354
8355
8356 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
8357   unsigned short jresult ;
8358   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8359   uint16_t result;
8360
8361   arg1 = (Dali::Uint16Pair *)jarg1;
8362   {
8363     try {
8364       result = ((Dali::Uint16Pair const *)arg1)->GetY();
8365     } catch (std::out_of_range& e) {
8366       {
8367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8368       };
8369     } catch (std::exception& e) {
8370       {
8371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8372       };
8373     } catch (...) {
8374       {
8375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8376       };
8377     }
8378   }
8379   jresult = result;
8380   return jresult;
8381 }
8382
8383
8384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
8385   void * jresult ;
8386   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8387   Dali::Uint16Pair *arg2 = 0 ;
8388   Dali::Uint16Pair *result = 0 ;
8389
8390   arg1 = (Dali::Uint16Pair *)jarg1;
8391   arg2 = (Dali::Uint16Pair *)jarg2;
8392   if (!arg2) {
8393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8394     return 0;
8395   }
8396   {
8397     try {
8398       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
8399     } catch (std::out_of_range& e) {
8400       {
8401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8402       };
8403     } catch (std::exception& e) {
8404       {
8405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8406       };
8407     } catch (...) {
8408       {
8409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8410       };
8411     }
8412   }
8413   jresult = (void *)result;
8414   return jresult;
8415 }
8416
8417
8418 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
8419   unsigned int jresult ;
8420   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8421   Dali::Uint16Pair *arg2 = 0 ;
8422   bool result;
8423
8424   arg1 = (Dali::Uint16Pair *)jarg1;
8425   arg2 = (Dali::Uint16Pair *)jarg2;
8426   if (!arg2) {
8427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8428     return 0;
8429   }
8430   {
8431     try {
8432       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
8433     } catch (std::out_of_range& e) {
8434       {
8435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8436       };
8437     } catch (std::exception& e) {
8438       {
8439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8440       };
8441     } catch (...) {
8442       {
8443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8444       };
8445     }
8446   }
8447   jresult = result;
8448   return jresult;
8449 }
8450
8451
8452 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
8453   unsigned int jresult ;
8454   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8455   Dali::Uint16Pair *arg2 = 0 ;
8456   bool result;
8457
8458   arg1 = (Dali::Uint16Pair *)jarg1;
8459   arg2 = (Dali::Uint16Pair *)jarg2;
8460   if (!arg2) {
8461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8462     return 0;
8463   }
8464   {
8465     try {
8466       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
8467     } catch (std::out_of_range& e) {
8468       {
8469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8470       };
8471     } catch (std::exception& e) {
8472       {
8473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8474       };
8475     } catch (...) {
8476       {
8477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8478       };
8479     }
8480   }
8481   jresult = result;
8482   return jresult;
8483 }
8484
8485
8486 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
8487   unsigned int jresult ;
8488   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8489   Dali::Uint16Pair *arg2 = 0 ;
8490   bool result;
8491
8492   arg1 = (Dali::Uint16Pair *)jarg1;
8493   arg2 = (Dali::Uint16Pair *)jarg2;
8494   if (!arg2) {
8495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8496     return 0;
8497   }
8498   {
8499     try {
8500       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
8501     } catch (std::out_of_range& e) {
8502       {
8503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8504       };
8505     } catch (std::exception& e) {
8506       {
8507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8508       };
8509     } catch (...) {
8510       {
8511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8512       };
8513     }
8514   }
8515   jresult = result;
8516   return jresult;
8517 }
8518
8519
8520 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
8521   unsigned int jresult ;
8522   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8523   Dali::Uint16Pair *arg2 = 0 ;
8524   bool result;
8525
8526   arg1 = (Dali::Uint16Pair *)jarg1;
8527   arg2 = (Dali::Uint16Pair *)jarg2;
8528   if (!arg2) {
8529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8530     return 0;
8531   }
8532   {
8533     try {
8534       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
8535     } catch (std::out_of_range& e) {
8536       {
8537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8538       };
8539     } catch (std::exception& e) {
8540       {
8541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8542       };
8543     } catch (...) {
8544       {
8545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8546       };
8547     }
8548   }
8549   jresult = result;
8550   return jresult;
8551 }
8552
8553
8554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
8555   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8556
8557   arg1 = (Dali::Uint16Pair *)jarg1;
8558   {
8559     try {
8560       delete arg1;
8561     } catch (std::out_of_range& e) {
8562       {
8563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8564       };
8565     } catch (std::exception& e) {
8566       {
8567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8568       };
8569     } catch (...) {
8570       {
8571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8572       };
8573     }
8574   }
8575 }
8576
8577
8578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
8579   void * jresult ;
8580   Dali::Degree *result = 0 ;
8581
8582   {
8583     try {
8584       result = (Dali::Degree *)new Dali::Degree();
8585     } catch (std::out_of_range& e) {
8586       {
8587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8588       };
8589     } catch (std::exception& e) {
8590       {
8591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8592       };
8593     } catch (...) {
8594       {
8595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8596       };
8597     }
8598   }
8599   jresult = (void *)result;
8600   return jresult;
8601 }
8602
8603
8604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
8605   void * jresult ;
8606   float arg1 ;
8607   Dali::Degree *result = 0 ;
8608
8609   arg1 = (float)jarg1;
8610   {
8611     try {
8612       result = (Dali::Degree *)new Dali::Degree(arg1);
8613     } catch (std::out_of_range& e) {
8614       {
8615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8616       };
8617     } catch (std::exception& e) {
8618       {
8619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8620       };
8621     } catch (...) {
8622       {
8623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8624       };
8625     }
8626   }
8627   jresult = (void *)result;
8628   return jresult;
8629 }
8630
8631
8632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
8633   void * jresult ;
8634   Dali::Radian arg1 ;
8635   Dali::Radian *argp1 ;
8636   Dali::Degree *result = 0 ;
8637
8638   argp1 = (Dali::Radian *)jarg1;
8639   if (!argp1) {
8640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8641     return 0;
8642   }
8643   arg1 = *argp1;
8644   {
8645     try {
8646       result = (Dali::Degree *)new Dali::Degree(arg1);
8647     } catch (std::out_of_range& e) {
8648       {
8649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8650       };
8651     } catch (std::exception& e) {
8652       {
8653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8654       };
8655     } catch (...) {
8656       {
8657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8658       };
8659     }
8660   }
8661   jresult = (void *)result;
8662   return jresult;
8663 }
8664
8665
8666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
8667   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8668   float arg2 ;
8669
8670   arg1 = (Dali::Degree *)jarg1;
8671   arg2 = (float)jarg2;
8672   if (arg1) (arg1)->degree = arg2;
8673 }
8674
8675
8676 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
8677   float jresult ;
8678   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8679   float result;
8680
8681   arg1 = (Dali::Degree *)jarg1;
8682   result = (float) ((arg1)->degree);
8683   jresult = result;
8684   return jresult;
8685 }
8686
8687
8688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
8689   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8690
8691   arg1 = (Dali::Degree *)jarg1;
8692   {
8693     try {
8694       delete arg1;
8695     } catch (std::out_of_range& e) {
8696       {
8697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8698       };
8699     } catch (std::exception& e) {
8700       {
8701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8702       };
8703     } catch (...) {
8704       {
8705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8706       };
8707     }
8708   }
8709 }
8710
8711
8712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
8713   void * jresult ;
8714   Dali::Radian *result = 0 ;
8715
8716   result = (Dali::Radian *)&Dali::ANGLE_360;
8717   jresult = (void *)result;
8718   return jresult;
8719 }
8720
8721
8722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
8723   void * jresult ;
8724   Dali::Radian *result = 0 ;
8725
8726   result = (Dali::Radian *)&Dali::ANGLE_315;
8727   jresult = (void *)result;
8728   return jresult;
8729 }
8730
8731
8732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
8733   void * jresult ;
8734   Dali::Radian *result = 0 ;
8735
8736   result = (Dali::Radian *)&Dali::ANGLE_270;
8737   jresult = (void *)result;
8738   return jresult;
8739 }
8740
8741
8742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
8743   void * jresult ;
8744   Dali::Radian *result = 0 ;
8745
8746   result = (Dali::Radian *)&Dali::ANGLE_225;
8747   jresult = (void *)result;
8748   return jresult;
8749 }
8750
8751
8752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
8753   void * jresult ;
8754   Dali::Radian *result = 0 ;
8755
8756   result = (Dali::Radian *)&Dali::ANGLE_180;
8757   jresult = (void *)result;
8758   return jresult;
8759 }
8760
8761
8762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
8763   void * jresult ;
8764   Dali::Radian *result = 0 ;
8765
8766   result = (Dali::Radian *)&Dali::ANGLE_135;
8767   jresult = (void *)result;
8768   return jresult;
8769 }
8770
8771
8772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
8773   void * jresult ;
8774   Dali::Radian *result = 0 ;
8775
8776   result = (Dali::Radian *)&Dali::ANGLE_120;
8777   jresult = (void *)result;
8778   return jresult;
8779 }
8780
8781
8782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
8783   void * jresult ;
8784   Dali::Radian *result = 0 ;
8785
8786   result = (Dali::Radian *)&Dali::ANGLE_90;
8787   jresult = (void *)result;
8788   return jresult;
8789 }
8790
8791
8792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
8793   void * jresult ;
8794   Dali::Radian *result = 0 ;
8795
8796   result = (Dali::Radian *)&Dali::ANGLE_60;
8797   jresult = (void *)result;
8798   return jresult;
8799 }
8800
8801
8802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
8803   void * jresult ;
8804   Dali::Radian *result = 0 ;
8805
8806   result = (Dali::Radian *)&Dali::ANGLE_45;
8807   jresult = (void *)result;
8808   return jresult;
8809 }
8810
8811
8812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
8813   void * jresult ;
8814   Dali::Radian *result = 0 ;
8815
8816   result = (Dali::Radian *)&Dali::ANGLE_30;
8817   jresult = (void *)result;
8818   return jresult;
8819 }
8820
8821
8822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
8823   void * jresult ;
8824   Dali::Radian *result = 0 ;
8825
8826   result = (Dali::Radian *)&Dali::ANGLE_0;
8827   jresult = (void *)result;
8828   return jresult;
8829 }
8830
8831
8832 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
8833   unsigned int jresult ;
8834   Dali::Degree *arg1 = 0 ;
8835   Dali::Degree *arg2 = 0 ;
8836   bool result;
8837
8838   arg1 = (Dali::Degree *)jarg1;
8839   if (!arg1) {
8840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8841     return 0;
8842   }
8843   arg2 = (Dali::Degree *)jarg2;
8844   if (!arg2) {
8845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8846     return 0;
8847   }
8848   {
8849     try {
8850       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8851     } catch (std::out_of_range& e) {
8852       {
8853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8854       };
8855     } catch (std::exception& e) {
8856       {
8857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8858       };
8859     } catch (...) {
8860       {
8861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8862       };
8863     }
8864   }
8865   jresult = result;
8866   return jresult;
8867 }
8868
8869
8870 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
8871   unsigned int jresult ;
8872   Dali::Degree *arg1 = 0 ;
8873   Dali::Degree *arg2 = 0 ;
8874   bool result;
8875
8876   arg1 = (Dali::Degree *)jarg1;
8877   if (!arg1) {
8878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8879     return 0;
8880   }
8881   arg2 = (Dali::Degree *)jarg2;
8882   if (!arg2) {
8883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8884     return 0;
8885   }
8886   {
8887     try {
8888       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8889     } catch (std::out_of_range& e) {
8890       {
8891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8892       };
8893     } catch (std::exception& e) {
8894       {
8895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8896       };
8897     } catch (...) {
8898       {
8899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8900       };
8901     }
8902   }
8903   jresult = result;
8904   return jresult;
8905 }
8906
8907
8908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
8909   void * jresult ;
8910   Dali::Degree arg1 ;
8911   float arg2 ;
8912   float arg3 ;
8913   Dali::Degree *argp1 ;
8914   Dali::Degree result;
8915
8916   argp1 = (Dali::Degree *)jarg1;
8917   if (!argp1) {
8918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8919     return 0;
8920   }
8921   arg1 = *argp1;
8922   arg2 = (float)jarg2;
8923   arg3 = (float)jarg3;
8924   {
8925     try {
8926       result = Dali::Clamp(arg1,arg2,arg3);
8927     } catch (std::out_of_range& e) {
8928       {
8929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8930       };
8931     } catch (std::exception& e) {
8932       {
8933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8934       };
8935     } catch (...) {
8936       {
8937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8938       };
8939     }
8940   }
8941   jresult = new Dali::Degree((const Dali::Degree &)result);
8942   return jresult;
8943 }
8944
8945
8946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
8947   void * jresult ;
8948   Dali::Radian *result = 0 ;
8949
8950   {
8951     try {
8952       result = (Dali::Radian *)new Dali::Radian();
8953     } catch (std::out_of_range& e) {
8954       {
8955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8956       };
8957     } catch (std::exception& e) {
8958       {
8959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8960       };
8961     } catch (...) {
8962       {
8963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8964       };
8965     }
8966   }
8967   jresult = (void *)result;
8968   return jresult;
8969 }
8970
8971
8972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
8973   void * jresult ;
8974   float arg1 ;
8975   Dali::Radian *result = 0 ;
8976
8977   arg1 = (float)jarg1;
8978   {
8979     try {
8980       result = (Dali::Radian *)new Dali::Radian(arg1);
8981     } catch (std::out_of_range& e) {
8982       {
8983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8984       };
8985     } catch (std::exception& e) {
8986       {
8987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8988       };
8989     } catch (...) {
8990       {
8991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8992       };
8993     }
8994   }
8995   jresult = (void *)result;
8996   return jresult;
8997 }
8998
8999
9000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
9001   void * jresult ;
9002   Dali::Degree arg1 ;
9003   Dali::Degree *argp1 ;
9004   Dali::Radian *result = 0 ;
9005
9006   argp1 = (Dali::Degree *)jarg1;
9007   if (!argp1) {
9008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9009     return 0;
9010   }
9011   arg1 = *argp1;
9012   {
9013     try {
9014       result = (Dali::Radian *)new Dali::Radian(arg1);
9015     } catch (std::out_of_range& e) {
9016       {
9017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9018       };
9019     } catch (std::exception& e) {
9020       {
9021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9022       };
9023     } catch (...) {
9024       {
9025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9026       };
9027     }
9028   }
9029   jresult = (void *)result;
9030   return jresult;
9031 }
9032
9033
9034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
9035   void * jresult ;
9036   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9037   float arg2 ;
9038   Dali::Radian *result = 0 ;
9039
9040   arg1 = (Dali::Radian *)jarg1;
9041   arg2 = (float)jarg2;
9042   {
9043     try {
9044       result = (Dali::Radian *) &(arg1)->operator =(arg2);
9045     } catch (std::out_of_range& e) {
9046       {
9047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9048       };
9049     } catch (std::exception& e) {
9050       {
9051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9052       };
9053     } catch (...) {
9054       {
9055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9056       };
9057     }
9058   }
9059   jresult = (void *)result;
9060   return jresult;
9061 }
9062
9063
9064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
9065   void * jresult ;
9066   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9067   Dali::Degree arg2 ;
9068   Dali::Degree *argp2 ;
9069   Dali::Radian *result = 0 ;
9070
9071   arg1 = (Dali::Radian *)jarg1;
9072   argp2 = (Dali::Degree *)jarg2;
9073   if (!argp2) {
9074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9075     return 0;
9076   }
9077   arg2 = *argp2;
9078   {
9079     try {
9080       result = (Dali::Radian *) &(arg1)->operator =(arg2);
9081     } catch (std::out_of_range& e) {
9082       {
9083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9084       };
9085     } catch (std::exception& e) {
9086       {
9087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9088       };
9089     } catch (...) {
9090       {
9091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9092       };
9093     }
9094   }
9095   jresult = (void *)result;
9096   return jresult;
9097 }
9098
9099
9100 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
9101   float jresult ;
9102   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9103   float result;
9104
9105   arg1 = (Dali::Radian *)jarg1;
9106   {
9107     try {
9108       result = (float)((Dali::Radian const *)arg1)->operator float();
9109     } catch (std::out_of_range& e) {
9110       {
9111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9112       };
9113     } catch (std::exception& e) {
9114       {
9115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9116       };
9117     } catch (...) {
9118       {
9119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9120       };
9121     }
9122   }
9123   jresult = result;
9124   return jresult;
9125 }
9126
9127
9128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
9129   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9130   float arg2 ;
9131
9132   arg1 = (Dali::Radian *)jarg1;
9133   arg2 = (float)jarg2;
9134   if (arg1) (arg1)->radian = arg2;
9135 }
9136
9137
9138 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
9139   float jresult ;
9140   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9141   float result;
9142
9143   arg1 = (Dali::Radian *)jarg1;
9144   result = (float) ((arg1)->radian);
9145   jresult = result;
9146   return jresult;
9147 }
9148
9149
9150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
9151   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9152
9153   arg1 = (Dali::Radian *)jarg1;
9154   {
9155     try {
9156       delete arg1;
9157     } catch (std::out_of_range& e) {
9158       {
9159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9160       };
9161     } catch (std::exception& e) {
9162       {
9163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9164       };
9165     } catch (...) {
9166       {
9167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9168       };
9169     }
9170   }
9171 }
9172
9173
9174 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
9175   unsigned int jresult ;
9176   Dali::Radian arg1 ;
9177   Dali::Radian arg2 ;
9178   Dali::Radian *argp1 ;
9179   Dali::Radian *argp2 ;
9180   bool result;
9181
9182   argp1 = (Dali::Radian *)jarg1;
9183   if (!argp1) {
9184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9185     return 0;
9186   }
9187   arg1 = *argp1;
9188   argp2 = (Dali::Radian *)jarg2;
9189   if (!argp2) {
9190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9191     return 0;
9192   }
9193   arg2 = *argp2;
9194   {
9195     try {
9196       result = (bool)Dali::operator ==(arg1,arg2);
9197     } catch (std::out_of_range& e) {
9198       {
9199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9200       };
9201     } catch (std::exception& e) {
9202       {
9203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9204       };
9205     } catch (...) {
9206       {
9207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9208       };
9209     }
9210   }
9211   jresult = result;
9212   return jresult;
9213 }
9214
9215
9216 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
9217   unsigned int jresult ;
9218   Dali::Radian arg1 ;
9219   Dali::Radian arg2 ;
9220   Dali::Radian *argp1 ;
9221   Dali::Radian *argp2 ;
9222   bool result;
9223
9224   argp1 = (Dali::Radian *)jarg1;
9225   if (!argp1) {
9226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9227     return 0;
9228   }
9229   arg1 = *argp1;
9230   argp2 = (Dali::Radian *)jarg2;
9231   if (!argp2) {
9232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9233     return 0;
9234   }
9235   arg2 = *argp2;
9236   {
9237     try {
9238       result = (bool)Dali::operator !=(arg1,arg2);
9239     } catch (std::out_of_range& e) {
9240       {
9241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9242       };
9243     } catch (std::exception& e) {
9244       {
9245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9246       };
9247     } catch (...) {
9248       {
9249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9250       };
9251     }
9252   }
9253   jresult = result;
9254   return jresult;
9255 }
9256
9257
9258 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
9259   unsigned int jresult ;
9260   Dali::Radian arg1 ;
9261   Dali::Degree arg2 ;
9262   Dali::Radian *argp1 ;
9263   Dali::Degree *argp2 ;
9264   bool result;
9265
9266   argp1 = (Dali::Radian *)jarg1;
9267   if (!argp1) {
9268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9269     return 0;
9270   }
9271   arg1 = *argp1;
9272   argp2 = (Dali::Degree *)jarg2;
9273   if (!argp2) {
9274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9275     return 0;
9276   }
9277   arg2 = *argp2;
9278   {
9279     try {
9280       result = (bool)Dali::operator ==(arg1,arg2);
9281     } catch (std::out_of_range& e) {
9282       {
9283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9284       };
9285     } catch (std::exception& e) {
9286       {
9287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9288       };
9289     } catch (...) {
9290       {
9291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9292       };
9293     }
9294   }
9295   jresult = result;
9296   return jresult;
9297 }
9298
9299
9300 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
9301   unsigned int jresult ;
9302   Dali::Radian arg1 ;
9303   Dali::Degree arg2 ;
9304   Dali::Radian *argp1 ;
9305   Dali::Degree *argp2 ;
9306   bool result;
9307
9308   argp1 = (Dali::Radian *)jarg1;
9309   if (!argp1) {
9310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9311     return 0;
9312   }
9313   arg1 = *argp1;
9314   argp2 = (Dali::Degree *)jarg2;
9315   if (!argp2) {
9316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9317     return 0;
9318   }
9319   arg2 = *argp2;
9320   {
9321     try {
9322       result = (bool)Dali::operator !=(arg1,arg2);
9323     } catch (std::out_of_range& e) {
9324       {
9325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9326       };
9327     } catch (std::exception& e) {
9328       {
9329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9330       };
9331     } catch (...) {
9332       {
9333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9334       };
9335     }
9336   }
9337   jresult = result;
9338   return jresult;
9339 }
9340
9341
9342 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
9343   unsigned int jresult ;
9344   Dali::Degree arg1 ;
9345   Dali::Radian arg2 ;
9346   Dali::Degree *argp1 ;
9347   Dali::Radian *argp2 ;
9348   bool result;
9349
9350   argp1 = (Dali::Degree *)jarg1;
9351   if (!argp1) {
9352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9353     return 0;
9354   }
9355   arg1 = *argp1;
9356   argp2 = (Dali::Radian *)jarg2;
9357   if (!argp2) {
9358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9359     return 0;
9360   }
9361   arg2 = *argp2;
9362   {
9363     try {
9364       result = (bool)Dali::operator ==(arg1,arg2);
9365     } catch (std::out_of_range& e) {
9366       {
9367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9368       };
9369     } catch (std::exception& e) {
9370       {
9371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9372       };
9373     } catch (...) {
9374       {
9375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9376       };
9377     }
9378   }
9379   jresult = result;
9380   return jresult;
9381 }
9382
9383
9384 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
9385   unsigned int jresult ;
9386   Dali::Degree arg1 ;
9387   Dali::Radian arg2 ;
9388   Dali::Degree *argp1 ;
9389   Dali::Radian *argp2 ;
9390   bool result;
9391
9392   argp1 = (Dali::Degree *)jarg1;
9393   if (!argp1) {
9394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9395     return 0;
9396   }
9397   arg1 = *argp1;
9398   argp2 = (Dali::Radian *)jarg2;
9399   if (!argp2) {
9400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9401     return 0;
9402   }
9403   arg2 = *argp2;
9404   {
9405     try {
9406       result = (bool)Dali::operator !=(arg1,arg2);
9407     } catch (std::out_of_range& e) {
9408       {
9409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9410       };
9411     } catch (std::exception& e) {
9412       {
9413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9414       };
9415     } catch (...) {
9416       {
9417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9418       };
9419     }
9420   }
9421   jresult = result;
9422   return jresult;
9423 }
9424
9425
9426 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
9427   unsigned int jresult ;
9428   Dali::Radian arg1 ;
9429   Dali::Radian arg2 ;
9430   Dali::Radian *argp1 ;
9431   Dali::Radian *argp2 ;
9432   bool result;
9433
9434   argp1 = (Dali::Radian *)jarg1;
9435   if (!argp1) {
9436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9437     return 0;
9438   }
9439   arg1 = *argp1;
9440   argp2 = (Dali::Radian *)jarg2;
9441   if (!argp2) {
9442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9443     return 0;
9444   }
9445   arg2 = *argp2;
9446   {
9447     try {
9448       result = (bool)Dali::operator >(arg1,arg2);
9449     } catch (std::out_of_range& e) {
9450       {
9451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9452       };
9453     } catch (std::exception& e) {
9454       {
9455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9456       };
9457     } catch (...) {
9458       {
9459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9460       };
9461     }
9462   }
9463   jresult = result;
9464   return jresult;
9465 }
9466
9467
9468 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
9469   unsigned int jresult ;
9470   Dali::Radian arg1 ;
9471   Dali::Degree arg2 ;
9472   Dali::Radian *argp1 ;
9473   Dali::Degree *argp2 ;
9474   bool result;
9475
9476   argp1 = (Dali::Radian *)jarg1;
9477   if (!argp1) {
9478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9479     return 0;
9480   }
9481   arg1 = *argp1;
9482   argp2 = (Dali::Degree *)jarg2;
9483   if (!argp2) {
9484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9485     return 0;
9486   }
9487   arg2 = *argp2;
9488   {
9489     try {
9490       result = (bool)Dali::operator >(arg1,arg2);
9491     } catch (std::out_of_range& e) {
9492       {
9493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9494       };
9495     } catch (std::exception& e) {
9496       {
9497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9498       };
9499     } catch (...) {
9500       {
9501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9502       };
9503     }
9504   }
9505   jresult = result;
9506   return jresult;
9507 }
9508
9509
9510 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
9511   unsigned int jresult ;
9512   Dali::Degree arg1 ;
9513   Dali::Radian arg2 ;
9514   Dali::Degree *argp1 ;
9515   Dali::Radian *argp2 ;
9516   bool result;
9517
9518   argp1 = (Dali::Degree *)jarg1;
9519   if (!argp1) {
9520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9521     return 0;
9522   }
9523   arg1 = *argp1;
9524   argp2 = (Dali::Radian *)jarg2;
9525   if (!argp2) {
9526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9527     return 0;
9528   }
9529   arg2 = *argp2;
9530   {
9531     try {
9532       result = (bool)Dali::operator >(arg1,arg2);
9533     } catch (std::out_of_range& e) {
9534       {
9535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9536       };
9537     } catch (std::exception& e) {
9538       {
9539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9540       };
9541     } catch (...) {
9542       {
9543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9544       };
9545     }
9546   }
9547   jresult = result;
9548   return jresult;
9549 }
9550
9551
9552 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
9553   unsigned int jresult ;
9554   Dali::Radian arg1 ;
9555   Dali::Radian arg2 ;
9556   Dali::Radian *argp1 ;
9557   Dali::Radian *argp2 ;
9558   bool result;
9559
9560   argp1 = (Dali::Radian *)jarg1;
9561   if (!argp1) {
9562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9563     return 0;
9564   }
9565   arg1 = *argp1;
9566   argp2 = (Dali::Radian *)jarg2;
9567   if (!argp2) {
9568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9569     return 0;
9570   }
9571   arg2 = *argp2;
9572   {
9573     try {
9574       result = (bool)Dali::operator <(arg1,arg2);
9575     } catch (std::out_of_range& e) {
9576       {
9577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9578       };
9579     } catch (std::exception& e) {
9580       {
9581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9582       };
9583     } catch (...) {
9584       {
9585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9586       };
9587     }
9588   }
9589   jresult = result;
9590   return jresult;
9591 }
9592
9593
9594 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
9595   unsigned int jresult ;
9596   Dali::Radian arg1 ;
9597   Dali::Degree arg2 ;
9598   Dali::Radian *argp1 ;
9599   Dali::Degree *argp2 ;
9600   bool result;
9601
9602   argp1 = (Dali::Radian *)jarg1;
9603   if (!argp1) {
9604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9605     return 0;
9606   }
9607   arg1 = *argp1;
9608   argp2 = (Dali::Degree *)jarg2;
9609   if (!argp2) {
9610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9611     return 0;
9612   }
9613   arg2 = *argp2;
9614   {
9615     try {
9616       result = (bool)Dali::operator <(arg1,arg2);
9617     } catch (std::out_of_range& e) {
9618       {
9619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9620       };
9621     } catch (std::exception& e) {
9622       {
9623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9624       };
9625     } catch (...) {
9626       {
9627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9628       };
9629     }
9630   }
9631   jresult = result;
9632   return jresult;
9633 }
9634
9635
9636 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
9637   unsigned int jresult ;
9638   Dali::Degree arg1 ;
9639   Dali::Radian arg2 ;
9640   Dali::Degree *argp1 ;
9641   Dali::Radian *argp2 ;
9642   bool result;
9643
9644   argp1 = (Dali::Degree *)jarg1;
9645   if (!argp1) {
9646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9647     return 0;
9648   }
9649   arg1 = *argp1;
9650   argp2 = (Dali::Radian *)jarg2;
9651   if (!argp2) {
9652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9653     return 0;
9654   }
9655   arg2 = *argp2;
9656   {
9657     try {
9658       result = (bool)Dali::operator <(arg1,arg2);
9659     } catch (std::out_of_range& e) {
9660       {
9661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9662       };
9663     } catch (std::exception& e) {
9664       {
9665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9666       };
9667     } catch (...) {
9668       {
9669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9670       };
9671     }
9672   }
9673   jresult = result;
9674   return jresult;
9675 }
9676
9677
9678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
9679   void * jresult ;
9680   Dali::Radian arg1 ;
9681   float arg2 ;
9682   Dali::Radian *argp1 ;
9683   Dali::Radian result;
9684
9685   argp1 = (Dali::Radian *)jarg1;
9686   if (!argp1) {
9687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9688     return 0;
9689   }
9690   arg1 = *argp1;
9691   arg2 = (float)jarg2;
9692   {
9693     try {
9694       result = Dali::operator *(arg1,arg2);
9695     } catch (std::out_of_range& e) {
9696       {
9697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9698       };
9699     } catch (std::exception& e) {
9700       {
9701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9702       };
9703     } catch (...) {
9704       {
9705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9706       };
9707     }
9708   }
9709   jresult = new Dali::Radian((const Dali::Radian &)result);
9710   return jresult;
9711 }
9712
9713
9714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
9715   void * jresult ;
9716   Dali::Radian arg1 ;
9717   Dali::Radian *argp1 ;
9718   Dali::Radian result;
9719
9720   argp1 = (Dali::Radian *)jarg1;
9721   if (!argp1) {
9722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9723     return 0;
9724   }
9725   arg1 = *argp1;
9726   {
9727     try {
9728       result = Dali::operator -(arg1);
9729     } catch (std::out_of_range& e) {
9730       {
9731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9732       };
9733     } catch (std::exception& e) {
9734       {
9735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9736       };
9737     } catch (...) {
9738       {
9739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9740       };
9741     }
9742   }
9743   jresult = new Dali::Radian((const Dali::Radian &)result);
9744   return jresult;
9745 }
9746
9747
9748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
9749   void * jresult ;
9750   Dali::Radian arg1 ;
9751   float arg2 ;
9752   float arg3 ;
9753   Dali::Radian *argp1 ;
9754   Dali::Radian result;
9755
9756   argp1 = (Dali::Radian *)jarg1;
9757   if (!argp1) {
9758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9759     return 0;
9760   }
9761   arg1 = *argp1;
9762   arg2 = (float)jarg2;
9763   arg3 = (float)jarg3;
9764   {
9765     try {
9766       result = Dali::Clamp(arg1,arg2,arg3);
9767     } catch (std::out_of_range& e) {
9768       {
9769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9770       };
9771     } catch (std::exception& e) {
9772       {
9773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9774       };
9775     } catch (...) {
9776       {
9777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9778       };
9779     }
9780   }
9781   jresult = new Dali::Radian((const Dali::Radian &)result);
9782   return jresult;
9783 }
9784
9785
9786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
9787   void * jresult ;
9788   Dali::Quaternion *result = 0 ;
9789
9790   {
9791     try {
9792       result = (Dali::Quaternion *)new Dali::Quaternion();
9793     } catch (std::out_of_range& e) {
9794       {
9795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9796       };
9797     } catch (std::exception& e) {
9798       {
9799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9800       };
9801     } catch (...) {
9802       {
9803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9804       };
9805     }
9806   }
9807   jresult = (void *)result;
9808   return jresult;
9809 }
9810
9811
9812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
9813   void * jresult ;
9814   Dali::Radian arg1 ;
9815   Dali::Vector3 *arg2 = 0 ;
9816   Dali::Radian *argp1 ;
9817   Dali::Quaternion *result = 0 ;
9818
9819   argp1 = (Dali::Radian *)jarg1;
9820   if (!argp1) {
9821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9822     return 0;
9823   }
9824   arg1 = *argp1;
9825   arg2 = (Dali::Vector3 *)jarg2;
9826   if (!arg2) {
9827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9828     return 0;
9829   }
9830   {
9831     try {
9832       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
9833     } catch (std::out_of_range& e) {
9834       {
9835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9836       };
9837     } catch (std::exception& e) {
9838       {
9839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9840       };
9841     } catch (...) {
9842       {
9843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9844       };
9845     }
9846   }
9847   jresult = (void *)result;
9848   return jresult;
9849 }
9850
9851
9852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
9853   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9854
9855   arg1 = (Dali::Quaternion *)jarg1;
9856   {
9857     try {
9858       delete arg1;
9859     } catch (std::out_of_range& e) {
9860       {
9861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9862       };
9863     } catch (std::exception& e) {
9864       {
9865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9866       };
9867     } catch (...) {
9868       {
9869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9870       };
9871     }
9872   }
9873 }
9874
9875
9876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
9877   void * jresult ;
9878   Dali::Quaternion *result = 0 ;
9879
9880   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
9881   jresult = (void *)result;
9882   return jresult;
9883 }
9884
9885
9886 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
9887   unsigned int jresult ;
9888   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9889   bool result;
9890
9891   arg1 = (Dali::Quaternion *)jarg1;
9892   {
9893     try {
9894       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
9895     } catch (std::out_of_range& e) {
9896       {
9897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9898       };
9899     } catch (std::exception& e) {
9900       {
9901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9902       };
9903     } catch (...) {
9904       {
9905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9906       };
9907     }
9908   }
9909   jresult = result;
9910   return jresult;
9911 }
9912
9913
9914 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
9915   unsigned int jresult ;
9916   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9917   Dali::Vector3 *arg2 = 0 ;
9918   Dali::Radian *arg3 = 0 ;
9919   bool result;
9920
9921   arg1 = (Dali::Quaternion *)jarg1;
9922   arg2 = (Dali::Vector3 *)jarg2;
9923   if (!arg2) {
9924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
9925     return 0;
9926   }
9927   arg3 = (Dali::Radian *)jarg3;
9928   if (!arg3) {
9929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
9930     return 0;
9931   }
9932   {
9933     try {
9934       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
9935     } catch (std::out_of_range& e) {
9936       {
9937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9938       };
9939     } catch (std::exception& e) {
9940       {
9941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9942       };
9943     } catch (...) {
9944       {
9945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9946       };
9947     }
9948   }
9949   jresult = result;
9950   return jresult;
9951 }
9952
9953
9954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
9955   void * jresult ;
9956   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9957   Dali::Quaternion *arg2 = 0 ;
9958   Dali::Quaternion result;
9959
9960   arg1 = (Dali::Quaternion *)jarg1;
9961   arg2 = (Dali::Quaternion *)jarg2;
9962   if (!arg2) {
9963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9964     return 0;
9965   }
9966   {
9967     try {
9968       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
9969     } catch (std::out_of_range& e) {
9970       {
9971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9972       };
9973     } catch (std::exception& e) {
9974       {
9975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9976       };
9977     } catch (...) {
9978       {
9979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9980       };
9981     }
9982   }
9983   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9984   return jresult;
9985 }
9986
9987
9988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
9989   void * jresult ;
9990   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9991   Dali::Quaternion *arg2 = 0 ;
9992   Dali::Quaternion result;
9993
9994   arg1 = (Dali::Quaternion *)jarg1;
9995   arg2 = (Dali::Quaternion *)jarg2;
9996   if (!arg2) {
9997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9998     return 0;
9999   }
10000   {
10001     try {
10002       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
10003     } catch (std::out_of_range& e) {
10004       {
10005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10006       };
10007     } catch (std::exception& e) {
10008       {
10009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10010       };
10011     } catch (...) {
10012       {
10013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10014       };
10015     }
10016   }
10017   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10018   return jresult;
10019 }
10020
10021
10022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
10023   void * jresult ;
10024   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10025   Dali::Quaternion *arg2 = 0 ;
10026   Dali::Quaternion result;
10027
10028   arg1 = (Dali::Quaternion *)jarg1;
10029   arg2 = (Dali::Quaternion *)jarg2;
10030   if (!arg2) {
10031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10032     return 0;
10033   }
10034   {
10035     try {
10036       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
10037     } catch (std::out_of_range& e) {
10038       {
10039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10040       };
10041     } catch (std::exception& e) {
10042       {
10043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10044       };
10045     } catch (...) {
10046       {
10047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10048       };
10049     }
10050   }
10051   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10052   return jresult;
10053 }
10054
10055
10056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
10057   void * jresult ;
10058   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10059   Dali::Vector3 *arg2 = 0 ;
10060   Dali::Vector3 result;
10061
10062   arg1 = (Dali::Quaternion *)jarg1;
10063   arg2 = (Dali::Vector3 *)jarg2;
10064   if (!arg2) {
10065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10066     return 0;
10067   }
10068   {
10069     try {
10070       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
10071     } catch (std::out_of_range& e) {
10072       {
10073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10074       };
10075     } catch (std::exception& e) {
10076       {
10077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10078       };
10079     } catch (...) {
10080       {
10081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10082       };
10083     }
10084   }
10085   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
10086   return jresult;
10087 }
10088
10089
10090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
10091   void * jresult ;
10092   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10093   Dali::Quaternion *arg2 = 0 ;
10094   Dali::Quaternion result;
10095
10096   arg1 = (Dali::Quaternion *)jarg1;
10097   arg2 = (Dali::Quaternion *)jarg2;
10098   if (!arg2) {
10099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10100     return 0;
10101   }
10102   {
10103     try {
10104       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
10105     } catch (std::out_of_range& e) {
10106       {
10107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10108       };
10109     } catch (std::exception& e) {
10110       {
10111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10112       };
10113     } catch (...) {
10114       {
10115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10116       };
10117     }
10118   }
10119   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10120   return jresult;
10121 }
10122
10123
10124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
10125   void * jresult ;
10126   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10127   float arg2 ;
10128   Dali::Quaternion result;
10129
10130   arg1 = (Dali::Quaternion *)jarg1;
10131   arg2 = (float)jarg2;
10132   {
10133     try {
10134       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
10135     } catch (std::out_of_range& e) {
10136       {
10137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10138       };
10139     } catch (std::exception& e) {
10140       {
10141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10142       };
10143     } catch (...) {
10144       {
10145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10146       };
10147     }
10148   }
10149   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10150   return jresult;
10151 }
10152
10153
10154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
10155   void * jresult ;
10156   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10157   float arg2 ;
10158   Dali::Quaternion result;
10159
10160   arg1 = (Dali::Quaternion *)jarg1;
10161   arg2 = (float)jarg2;
10162   {
10163     try {
10164       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
10165     } catch (std::out_of_range& e) {
10166       {
10167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10168       };
10169     } catch (std::exception& e) {
10170       {
10171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10172       };
10173     } catch (...) {
10174       {
10175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10176       };
10177     }
10178   }
10179   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10180   return jresult;
10181 }
10182
10183
10184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
10185   void * jresult ;
10186   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10187   Dali::Quaternion result;
10188
10189   arg1 = (Dali::Quaternion *)jarg1;
10190   {
10191     try {
10192       result = ((Dali::Quaternion const *)arg1)->operator -();
10193     } catch (std::out_of_range& e) {
10194       {
10195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10196       };
10197     } catch (std::exception& e) {
10198       {
10199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10200       };
10201     } catch (...) {
10202       {
10203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10204       };
10205     }
10206   }
10207   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10208   return jresult;
10209 }
10210
10211
10212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
10213   void * jresult ;
10214   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10215   Dali::Quaternion *arg2 = 0 ;
10216   Dali::Quaternion *result = 0 ;
10217
10218   arg1 = (Dali::Quaternion *)jarg1;
10219   arg2 = (Dali::Quaternion *)jarg2;
10220   if (!arg2) {
10221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10222     return 0;
10223   }
10224   {
10225     try {
10226       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
10227     } catch (std::out_of_range& e) {
10228       {
10229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10230       };
10231     } catch (std::exception& e) {
10232       {
10233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10234       };
10235     } catch (...) {
10236       {
10237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10238       };
10239     }
10240   }
10241   jresult = (void *)result;
10242   return jresult;
10243 }
10244
10245
10246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
10247   void * jresult ;
10248   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10249   Dali::Quaternion *arg2 = 0 ;
10250   Dali::Quaternion *result = 0 ;
10251
10252   arg1 = (Dali::Quaternion *)jarg1;
10253   arg2 = (Dali::Quaternion *)jarg2;
10254   if (!arg2) {
10255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10256     return 0;
10257   }
10258   {
10259     try {
10260       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
10261     } catch (std::out_of_range& e) {
10262       {
10263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10264       };
10265     } catch (std::exception& e) {
10266       {
10267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10268       };
10269     } catch (...) {
10270       {
10271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10272       };
10273     }
10274   }
10275   jresult = (void *)result;
10276   return jresult;
10277 }
10278
10279
10280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
10281   void * jresult ;
10282   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10283   Dali::Quaternion *arg2 = 0 ;
10284   Dali::Quaternion *result = 0 ;
10285
10286   arg1 = (Dali::Quaternion *)jarg1;
10287   arg2 = (Dali::Quaternion *)jarg2;
10288   if (!arg2) {
10289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10290     return 0;
10291   }
10292   {
10293     try {
10294       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
10295     } catch (std::out_of_range& e) {
10296       {
10297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10298       };
10299     } catch (std::exception& e) {
10300       {
10301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10302       };
10303     } catch (...) {
10304       {
10305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10306       };
10307     }
10308   }
10309   jresult = (void *)result;
10310   return jresult;
10311 }
10312
10313
10314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
10315   void * jresult ;
10316   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10317   float arg2 ;
10318   Dali::Quaternion *result = 0 ;
10319
10320   arg1 = (Dali::Quaternion *)jarg1;
10321   arg2 = (float)jarg2;
10322   {
10323     try {
10324       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
10325     } catch (std::out_of_range& e) {
10326       {
10327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10328       };
10329     } catch (std::exception& e) {
10330       {
10331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10332       };
10333     } catch (...) {
10334       {
10335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10336       };
10337     }
10338   }
10339   jresult = (void *)result;
10340   return jresult;
10341 }
10342
10343
10344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
10345   void * jresult ;
10346   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10347   float arg2 ;
10348   Dali::Quaternion *result = 0 ;
10349
10350   arg1 = (Dali::Quaternion *)jarg1;
10351   arg2 = (float)jarg2;
10352   {
10353     try {
10354       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
10355     } catch (std::out_of_range& e) {
10356       {
10357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10358       };
10359     } catch (std::exception& e) {
10360       {
10361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10362       };
10363     } catch (...) {
10364       {
10365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10366       };
10367     }
10368   }
10369   jresult = (void *)result;
10370   return jresult;
10371 }
10372
10373
10374 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
10375   unsigned int jresult ;
10376   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10377   Dali::Quaternion *arg2 = 0 ;
10378   bool result;
10379
10380   arg1 = (Dali::Quaternion *)jarg1;
10381   arg2 = (Dali::Quaternion *)jarg2;
10382   if (!arg2) {
10383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10384     return 0;
10385   }
10386   {
10387     try {
10388       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
10389     } catch (std::out_of_range& e) {
10390       {
10391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10392       };
10393     } catch (std::exception& e) {
10394       {
10395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10396       };
10397     } catch (...) {
10398       {
10399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10400       };
10401     }
10402   }
10403   jresult = result;
10404   return jresult;
10405 }
10406
10407
10408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
10409   unsigned int jresult ;
10410   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10411   Dali::Quaternion *arg2 = 0 ;
10412   bool result;
10413
10414   arg1 = (Dali::Quaternion *)jarg1;
10415   arg2 = (Dali::Quaternion *)jarg2;
10416   if (!arg2) {
10417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10418     return 0;
10419   }
10420   {
10421     try {
10422       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
10423     } catch (std::out_of_range& e) {
10424       {
10425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10426       };
10427     } catch (std::exception& e) {
10428       {
10429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10430       };
10431     } catch (...) {
10432       {
10433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10434       };
10435     }
10436   }
10437   jresult = result;
10438   return jresult;
10439 }
10440
10441
10442 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
10443   float jresult ;
10444   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10445   float result;
10446
10447   arg1 = (Dali::Quaternion *)jarg1;
10448   {
10449     try {
10450       result = (float)((Dali::Quaternion const *)arg1)->Length();
10451     } catch (std::out_of_range& e) {
10452       {
10453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10454       };
10455     } catch (std::exception& e) {
10456       {
10457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10458       };
10459     } catch (...) {
10460       {
10461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10462       };
10463     }
10464   }
10465   jresult = result;
10466   return jresult;
10467 }
10468
10469
10470 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
10471   float jresult ;
10472   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10473   float result;
10474
10475   arg1 = (Dali::Quaternion *)jarg1;
10476   {
10477     try {
10478       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
10479     } catch (std::out_of_range& e) {
10480       {
10481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10482       };
10483     } catch (std::exception& e) {
10484       {
10485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10486       };
10487     } catch (...) {
10488       {
10489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10490       };
10491     }
10492   }
10493   jresult = result;
10494   return jresult;
10495 }
10496
10497
10498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
10499   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10500
10501   arg1 = (Dali::Quaternion *)jarg1;
10502   {
10503     try {
10504       (arg1)->Normalize();
10505     } catch (std::out_of_range& e) {
10506       {
10507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10508       };
10509     } catch (std::exception& e) {
10510       {
10511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10512       };
10513     } catch (...) {
10514       {
10515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10516       };
10517     }
10518   }
10519 }
10520
10521
10522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
10523   void * jresult ;
10524   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10525   Dali::Quaternion result;
10526
10527   arg1 = (Dali::Quaternion *)jarg1;
10528   {
10529     try {
10530       result = ((Dali::Quaternion const *)arg1)->Normalized();
10531     } catch (std::out_of_range& e) {
10532       {
10533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10534       };
10535     } catch (std::exception& e) {
10536       {
10537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10538       };
10539     } catch (...) {
10540       {
10541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10542       };
10543     }
10544   }
10545   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10546   return jresult;
10547 }
10548
10549
10550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
10551   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10552
10553   arg1 = (Dali::Quaternion *)jarg1;
10554   {
10555     try {
10556       (arg1)->Conjugate();
10557     } catch (std::out_of_range& e) {
10558       {
10559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10560       };
10561     } catch (std::exception& e) {
10562       {
10563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10564       };
10565     } catch (...) {
10566       {
10567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10568       };
10569     }
10570   }
10571 }
10572
10573
10574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
10575   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10576
10577   arg1 = (Dali::Quaternion *)jarg1;
10578   {
10579     try {
10580       (arg1)->Invert();
10581     } catch (std::out_of_range& e) {
10582       {
10583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10584       };
10585     } catch (std::exception& e) {
10586       {
10587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10588       };
10589     } catch (...) {
10590       {
10591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10592       };
10593     }
10594   }
10595 }
10596
10597
10598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
10599   void * jresult ;
10600   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10601   Dali::Quaternion result;
10602
10603   arg1 = (Dali::Quaternion *)jarg1;
10604   {
10605     try {
10606       result = ((Dali::Quaternion const *)arg1)->Log();
10607     } catch (std::out_of_range& e) {
10608       {
10609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10610       };
10611     } catch (std::exception& e) {
10612       {
10613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10614       };
10615     } catch (...) {
10616       {
10617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10618       };
10619     }
10620   }
10621   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10622   return jresult;
10623 }
10624
10625
10626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
10627   void * jresult ;
10628   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10629   Dali::Quaternion result;
10630
10631   arg1 = (Dali::Quaternion *)jarg1;
10632   {
10633     try {
10634       result = ((Dali::Quaternion const *)arg1)->Exp();
10635     } catch (std::out_of_range& e) {
10636       {
10637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10638       };
10639     } catch (std::exception& e) {
10640       {
10641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10642       };
10643     } catch (...) {
10644       {
10645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10646       };
10647     }
10648   }
10649   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10650   return jresult;
10651 }
10652
10653
10654 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
10655   float jresult ;
10656   Dali::Quaternion *arg1 = 0 ;
10657   Dali::Quaternion *arg2 = 0 ;
10658   float result;
10659
10660   arg1 = (Dali::Quaternion *)jarg1;
10661   if (!arg1) {
10662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10663     return 0;
10664   }
10665   arg2 = (Dali::Quaternion *)jarg2;
10666   if (!arg2) {
10667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10668     return 0;
10669   }
10670   {
10671     try {
10672       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10673     } catch (std::out_of_range& e) {
10674       {
10675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10676       };
10677     } catch (std::exception& e) {
10678       {
10679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10680       };
10681     } catch (...) {
10682       {
10683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10684       };
10685     }
10686   }
10687   jresult = result;
10688   return jresult;
10689 }
10690
10691
10692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
10693   void * jresult ;
10694   Dali::Quaternion *arg1 = 0 ;
10695   Dali::Quaternion *arg2 = 0 ;
10696   float arg3 ;
10697   Dali::Quaternion result;
10698
10699   arg1 = (Dali::Quaternion *)jarg1;
10700   if (!arg1) {
10701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10702     return 0;
10703   }
10704   arg2 = (Dali::Quaternion *)jarg2;
10705   if (!arg2) {
10706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10707     return 0;
10708   }
10709   arg3 = (float)jarg3;
10710   {
10711     try {
10712       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10713     } catch (std::out_of_range& e) {
10714       {
10715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10716       };
10717     } catch (std::exception& e) {
10718       {
10719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10720       };
10721     } catch (...) {
10722       {
10723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10724       };
10725     }
10726   }
10727   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10728   return jresult;
10729 }
10730
10731
10732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
10733   void * jresult ;
10734   Dali::Quaternion *arg1 = 0 ;
10735   Dali::Quaternion *arg2 = 0 ;
10736   float arg3 ;
10737   Dali::Quaternion result;
10738
10739   arg1 = (Dali::Quaternion *)jarg1;
10740   if (!arg1) {
10741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10742     return 0;
10743   }
10744   arg2 = (Dali::Quaternion *)jarg2;
10745   if (!arg2) {
10746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10747     return 0;
10748   }
10749   arg3 = (float)jarg3;
10750   {
10751     try {
10752       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10753     } catch (std::out_of_range& e) {
10754       {
10755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10756       };
10757     } catch (std::exception& e) {
10758       {
10759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10760       };
10761     } catch (...) {
10762       {
10763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10764       };
10765     }
10766   }
10767   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10768   return jresult;
10769 }
10770
10771
10772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
10773   void * jresult ;
10774   Dali::Quaternion *arg1 = 0 ;
10775   Dali::Quaternion *arg2 = 0 ;
10776   float arg3 ;
10777   Dali::Quaternion result;
10778
10779   arg1 = (Dali::Quaternion *)jarg1;
10780   if (!arg1) {
10781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10782     return 0;
10783   }
10784   arg2 = (Dali::Quaternion *)jarg2;
10785   if (!arg2) {
10786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10787     return 0;
10788   }
10789   arg3 = (float)jarg3;
10790   {
10791     try {
10792       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10793     } catch (std::out_of_range& e) {
10794       {
10795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10796       };
10797     } catch (std::exception& e) {
10798       {
10799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10800       };
10801     } catch (...) {
10802       {
10803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10804       };
10805     }
10806   }
10807   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10808   return jresult;
10809 }
10810
10811
10812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
10813   void * jresult ;
10814   Dali::Quaternion *arg1 = 0 ;
10815   Dali::Quaternion *arg2 = 0 ;
10816   Dali::Quaternion *arg3 = 0 ;
10817   Dali::Quaternion *arg4 = 0 ;
10818   float arg5 ;
10819   Dali::Quaternion result;
10820
10821   arg1 = (Dali::Quaternion *)jarg1;
10822   if (!arg1) {
10823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10824     return 0;
10825   }
10826   arg2 = (Dali::Quaternion *)jarg2;
10827   if (!arg2) {
10828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10829     return 0;
10830   }
10831   arg3 = (Dali::Quaternion *)jarg3;
10832   if (!arg3) {
10833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10834     return 0;
10835   }
10836   arg4 = (Dali::Quaternion *)jarg4;
10837   if (!arg4) {
10838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10839     return 0;
10840   }
10841   arg5 = (float)jarg5;
10842   {
10843     try {
10844       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
10845     } catch (std::out_of_range& e) {
10846       {
10847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10848       };
10849     } catch (std::exception& e) {
10850       {
10851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10852       };
10853     } catch (...) {
10854       {
10855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10856       };
10857     }
10858   }
10859   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10860   return jresult;
10861 }
10862
10863
10864 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
10865   float jresult ;
10866   Dali::Quaternion *arg1 = 0 ;
10867   Dali::Quaternion *arg2 = 0 ;
10868   float result;
10869
10870   arg1 = (Dali::Quaternion *)jarg1;
10871   if (!arg1) {
10872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10873     return 0;
10874   }
10875   arg2 = (Dali::Quaternion *)jarg2;
10876   if (!arg2) {
10877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10878     return 0;
10879   }
10880   {
10881     try {
10882       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10883     } catch (std::out_of_range& e) {
10884       {
10885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10886       };
10887     } catch (std::exception& e) {
10888       {
10889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10890       };
10891     } catch (...) {
10892       {
10893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10894       };
10895     }
10896   }
10897   jresult = result;
10898   return jresult;
10899 }
10900
10901
10902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
10903   void * jresult ;
10904   Dali::Matrix *result = 0 ;
10905
10906   {
10907     try {
10908       result = (Dali::Matrix *)new Dali::Matrix();
10909     } catch (std::out_of_range& e) {
10910       {
10911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10912       };
10913     } catch (std::exception& e) {
10914       {
10915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10916       };
10917     } catch (...) {
10918       {
10919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10920       };
10921     }
10922   }
10923   jresult = (void *)result;
10924   return jresult;
10925 }
10926
10927
10928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
10929   void * jresult ;
10930   bool arg1 ;
10931   Dali::Matrix *result = 0 ;
10932
10933   arg1 = jarg1 ? true : false;
10934   {
10935     try {
10936       result = (Dali::Matrix *)new Dali::Matrix(arg1);
10937     } catch (std::out_of_range& e) {
10938       {
10939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10940       };
10941     } catch (std::exception& e) {
10942       {
10943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10944       };
10945     } catch (...) {
10946       {
10947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10948       };
10949     }
10950   }
10951   jresult = (void *)result;
10952   return jresult;
10953 }
10954
10955
10956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
10957   void * jresult ;
10958   float *arg1 = (float *) 0 ;
10959   Dali::Matrix *result = 0 ;
10960
10961   arg1 = jarg1;
10962   {
10963     try {
10964       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
10965     } catch (std::out_of_range& e) {
10966       {
10967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10968       };
10969     } catch (std::exception& e) {
10970       {
10971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10972       };
10973     } catch (...) {
10974       {
10975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10976       };
10977     }
10978   }
10979   jresult = (void *)result;
10980
10981
10982   return jresult;
10983 }
10984
10985
10986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
10987   void * jresult ;
10988   Dali::Quaternion *arg1 = 0 ;
10989   Dali::Matrix *result = 0 ;
10990
10991   arg1 = (Dali::Quaternion *)jarg1;
10992   if (!arg1) {
10993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10994     return 0;
10995   }
10996   {
10997     try {
10998       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
10999     } catch (std::out_of_range& e) {
11000       {
11001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11002       };
11003     } catch (std::exception& e) {
11004       {
11005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11006       };
11007     } catch (...) {
11008       {
11009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11010       };
11011     }
11012   }
11013   jresult = (void *)result;
11014   return jresult;
11015 }
11016
11017
11018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
11019   void * jresult ;
11020   Dali::Matrix *arg1 = 0 ;
11021   Dali::Matrix *result = 0 ;
11022
11023   arg1 = (Dali::Matrix *)jarg1;
11024   if (!arg1) {
11025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11026     return 0;
11027   }
11028   {
11029     try {
11030       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
11031     } catch (std::out_of_range& e) {
11032       {
11033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11034       };
11035     } catch (std::exception& e) {
11036       {
11037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11038       };
11039     } catch (...) {
11040       {
11041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11042       };
11043     }
11044   }
11045   jresult = (void *)result;
11046   return jresult;
11047 }
11048
11049
11050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
11051   void * jresult ;
11052   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11053   Dali::Matrix *arg2 = 0 ;
11054   Dali::Matrix *result = 0 ;
11055
11056   arg1 = (Dali::Matrix *)jarg1;
11057   arg2 = (Dali::Matrix *)jarg2;
11058   if (!arg2) {
11059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11060     return 0;
11061   }
11062   {
11063     try {
11064       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
11065     } catch (std::out_of_range& e) {
11066       {
11067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11068       };
11069     } catch (std::exception& e) {
11070       {
11071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11072       };
11073     } catch (...) {
11074       {
11075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11076       };
11077     }
11078   }
11079   jresult = (void *)result;
11080   return jresult;
11081 }
11082
11083
11084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
11085   void * jresult ;
11086   Dali::Matrix *result = 0 ;
11087
11088   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
11089   jresult = (void *)result;
11090   return jresult;
11091 }
11092
11093
11094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
11095   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11096
11097   arg1 = (Dali::Matrix *)jarg1;
11098   {
11099     try {
11100       (arg1)->SetIdentity();
11101     } catch (std::out_of_range& e) {
11102       {
11103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11104       };
11105     } catch (std::exception& e) {
11106       {
11107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11108       };
11109     } catch (...) {
11110       {
11111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11112       };
11113     }
11114   }
11115 }
11116
11117
11118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
11119   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11120   Dali::Vector3 *arg2 = 0 ;
11121
11122   arg1 = (Dali::Matrix *)jarg1;
11123   arg2 = (Dali::Vector3 *)jarg2;
11124   if (!arg2) {
11125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11126     return ;
11127   }
11128   {
11129     try {
11130       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
11131     } catch (std::out_of_range& e) {
11132       {
11133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11134       };
11135     } catch (std::exception& e) {
11136       {
11137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11138       };
11139     } catch (...) {
11140       {
11141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11142       };
11143     }
11144   }
11145 }
11146
11147
11148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
11149   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11150   Dali::Matrix *arg2 = 0 ;
11151
11152   arg1 = (Dali::Matrix *)jarg1;
11153   arg2 = (Dali::Matrix *)jarg2;
11154   if (!arg2) {
11155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11156     return ;
11157   }
11158   {
11159     try {
11160       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
11161     } catch (std::out_of_range& e) {
11162       {
11163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11164       };
11165     } catch (std::exception& e) {
11166       {
11167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11168       };
11169     } catch (...) {
11170       {
11171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11172       };
11173     }
11174   }
11175 }
11176
11177
11178 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
11179   unsigned int jresult ;
11180   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11181   bool result;
11182
11183   arg1 = (Dali::Matrix *)jarg1;
11184   {
11185     try {
11186       result = (bool)(arg1)->Invert();
11187     } catch (std::out_of_range& e) {
11188       {
11189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11190       };
11191     } catch (std::exception& e) {
11192       {
11193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11194       };
11195     } catch (...) {
11196       {
11197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11198       };
11199     }
11200   }
11201   jresult = result;
11202   return jresult;
11203 }
11204
11205
11206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
11207   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11208
11209   arg1 = (Dali::Matrix *)jarg1;
11210   {
11211     try {
11212       (arg1)->Transpose();
11213     } catch (std::out_of_range& e) {
11214       {
11215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11216       };
11217     } catch (std::exception& e) {
11218       {
11219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11220       };
11221     } catch (...) {
11222       {
11223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11224       };
11225     }
11226   }
11227 }
11228
11229
11230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
11231   void * jresult ;
11232   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11233   Dali::Vector3 result;
11234
11235   arg1 = (Dali::Matrix *)jarg1;
11236   {
11237     try {
11238       result = ((Dali::Matrix const *)arg1)->GetXAxis();
11239     } catch (std::out_of_range& e) {
11240       {
11241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11242       };
11243     } catch (std::exception& e) {
11244       {
11245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11246       };
11247     } catch (...) {
11248       {
11249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11250       };
11251     }
11252   }
11253   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11254   return jresult;
11255 }
11256
11257
11258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
11259   void * jresult ;
11260   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11261   Dali::Vector3 result;
11262
11263   arg1 = (Dali::Matrix *)jarg1;
11264   {
11265     try {
11266       result = ((Dali::Matrix const *)arg1)->GetYAxis();
11267     } catch (std::out_of_range& e) {
11268       {
11269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11270       };
11271     } catch (std::exception& e) {
11272       {
11273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11274       };
11275     } catch (...) {
11276       {
11277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11278       };
11279     }
11280   }
11281   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11282   return jresult;
11283 }
11284
11285
11286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
11287   void * jresult ;
11288   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11289   Dali::Vector3 result;
11290
11291   arg1 = (Dali::Matrix *)jarg1;
11292   {
11293     try {
11294       result = ((Dali::Matrix const *)arg1)->GetZAxis();
11295     } catch (std::out_of_range& e) {
11296       {
11297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11298       };
11299     } catch (std::exception& e) {
11300       {
11301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11302       };
11303     } catch (...) {
11304       {
11305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11306       };
11307     }
11308   }
11309   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11310   return jresult;
11311 }
11312
11313
11314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
11315   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11316   Dali::Vector3 *arg2 = 0 ;
11317
11318   arg1 = (Dali::Matrix *)jarg1;
11319   arg2 = (Dali::Vector3 *)jarg2;
11320   if (!arg2) {
11321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11322     return ;
11323   }
11324   {
11325     try {
11326       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
11327     } catch (std::out_of_range& e) {
11328       {
11329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11330       };
11331     } catch (std::exception& e) {
11332       {
11333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11334       };
11335     } catch (...) {
11336       {
11337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11338       };
11339     }
11340   }
11341 }
11342
11343
11344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
11345   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11346   Dali::Vector3 *arg2 = 0 ;
11347
11348   arg1 = (Dali::Matrix *)jarg1;
11349   arg2 = (Dali::Vector3 *)jarg2;
11350   if (!arg2) {
11351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11352     return ;
11353   }
11354   {
11355     try {
11356       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
11357     } catch (std::out_of_range& e) {
11358       {
11359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11360       };
11361     } catch (std::exception& e) {
11362       {
11363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11364       };
11365     } catch (...) {
11366       {
11367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11368       };
11369     }
11370   }
11371 }
11372
11373
11374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
11375   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11376   Dali::Vector3 *arg2 = 0 ;
11377
11378   arg1 = (Dali::Matrix *)jarg1;
11379   arg2 = (Dali::Vector3 *)jarg2;
11380   if (!arg2) {
11381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11382     return ;
11383   }
11384   {
11385     try {
11386       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
11387     } catch (std::out_of_range& e) {
11388       {
11389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11390       };
11391     } catch (std::exception& e) {
11392       {
11393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11394       };
11395     } catch (...) {
11396       {
11397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11398       };
11399     }
11400   }
11401 }
11402
11403
11404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
11405   void * jresult ;
11406   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11407   Dali::Vector4 *result = 0 ;
11408
11409   arg1 = (Dali::Matrix *)jarg1;
11410   {
11411     try {
11412       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
11413     } catch (std::out_of_range& e) {
11414       {
11415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11416       };
11417     } catch (std::exception& e) {
11418       {
11419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11420       };
11421     } catch (...) {
11422       {
11423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11424       };
11425     }
11426   }
11427   jresult = (void *)result;
11428   return jresult;
11429 }
11430
11431
11432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
11433   void * jresult ;
11434   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11435   Dali::Vector3 *result = 0 ;
11436
11437   arg1 = (Dali::Matrix *)jarg1;
11438   {
11439     try {
11440       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
11441     } catch (std::out_of_range& e) {
11442       {
11443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11444       };
11445     } catch (std::exception& e) {
11446       {
11447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11448       };
11449     } catch (...) {
11450       {
11451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11452       };
11453     }
11454   }
11455   jresult = (void *)result;
11456   return jresult;
11457 }
11458
11459
11460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
11461   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11462   Dali::Vector4 *arg2 = 0 ;
11463
11464   arg1 = (Dali::Matrix *)jarg1;
11465   arg2 = (Dali::Vector4 *)jarg2;
11466   if (!arg2) {
11467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11468     return ;
11469   }
11470   {
11471     try {
11472       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
11473     } catch (std::out_of_range& e) {
11474       {
11475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11476       };
11477     } catch (std::exception& e) {
11478       {
11479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11480       };
11481     } catch (...) {
11482       {
11483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11484       };
11485     }
11486   }
11487 }
11488
11489
11490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
11491   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11492   Dali::Vector3 *arg2 = 0 ;
11493
11494   arg1 = (Dali::Matrix *)jarg1;
11495   arg2 = (Dali::Vector3 *)jarg2;
11496   if (!arg2) {
11497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11498     return ;
11499   }
11500   {
11501     try {
11502       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
11503     } catch (std::out_of_range& e) {
11504       {
11505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11506       };
11507     } catch (std::exception& e) {
11508       {
11509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11510       };
11511     } catch (...) {
11512       {
11513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11514       };
11515     }
11516   }
11517 }
11518
11519
11520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
11521   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11522
11523   arg1 = (Dali::Matrix *)jarg1;
11524   {
11525     try {
11526       (arg1)->OrthoNormalize();
11527     } catch (std::out_of_range& e) {
11528       {
11529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11530       };
11531     } catch (std::exception& e) {
11532       {
11533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11534       };
11535     } catch (...) {
11536       {
11537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11538       };
11539     }
11540   }
11541 }
11542
11543
11544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
11545   void * jresult ;
11546   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11547   float *result = 0 ;
11548
11549   arg1 = (Dali::Matrix *)jarg1;
11550   {
11551     try {
11552       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
11553     } catch (std::out_of_range& e) {
11554       {
11555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11556       };
11557     } catch (std::exception& e) {
11558       {
11559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11560       };
11561     } catch (...) {
11562       {
11563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11564       };
11565     }
11566   }
11567   jresult = (void *)result;
11568   return jresult;
11569 }
11570
11571
11572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
11573   Dali::Matrix *arg1 = 0 ;
11574   Dali::Matrix *arg2 = 0 ;
11575   Dali::Matrix *arg3 = 0 ;
11576
11577   arg1 = (Dali::Matrix *)jarg1;
11578   if (!arg1) {
11579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11580     return ;
11581   }
11582   arg2 = (Dali::Matrix *)jarg2;
11583   if (!arg2) {
11584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11585     return ;
11586   }
11587   arg3 = (Dali::Matrix *)jarg3;
11588   if (!arg3) {
11589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11590     return ;
11591   }
11592   {
11593     try {
11594       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
11595     } catch (std::out_of_range& e) {
11596       {
11597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11598       };
11599     } catch (std::exception& e) {
11600       {
11601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11602       };
11603     } catch (...) {
11604       {
11605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11606       };
11607     }
11608   }
11609 }
11610
11611
11612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
11613   Dali::Matrix *arg1 = 0 ;
11614   Dali::Matrix *arg2 = 0 ;
11615   Dali::Quaternion *arg3 = 0 ;
11616
11617   arg1 = (Dali::Matrix *)jarg1;
11618   if (!arg1) {
11619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11620     return ;
11621   }
11622   arg2 = (Dali::Matrix *)jarg2;
11623   if (!arg2) {
11624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11625     return ;
11626   }
11627   arg3 = (Dali::Quaternion *)jarg3;
11628   if (!arg3) {
11629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11630     return ;
11631   }
11632   {
11633     try {
11634       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
11635     } catch (std::out_of_range& e) {
11636       {
11637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11638       };
11639     } catch (std::exception& e) {
11640       {
11641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11642       };
11643     } catch (...) {
11644       {
11645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11646       };
11647     }
11648   }
11649 }
11650
11651
11652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
11653   void * jresult ;
11654   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11655   Dali::Vector4 *arg2 = 0 ;
11656   Dali::Vector4 result;
11657
11658   arg1 = (Dali::Matrix *)jarg1;
11659   arg2 = (Dali::Vector4 *)jarg2;
11660   if (!arg2) {
11661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11662     return 0;
11663   }
11664   {
11665     try {
11666       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
11667     } catch (std::out_of_range& e) {
11668       {
11669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11670       };
11671     } catch (std::exception& e) {
11672       {
11673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11674       };
11675     } catch (...) {
11676       {
11677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11678       };
11679     }
11680   }
11681   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
11682   return jresult;
11683 }
11684
11685
11686 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
11687   unsigned int jresult ;
11688   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11689   Dali::Matrix *arg2 = 0 ;
11690   bool result;
11691
11692   arg1 = (Dali::Matrix *)jarg1;
11693   arg2 = (Dali::Matrix *)jarg2;
11694   if (!arg2) {
11695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11696     return 0;
11697   }
11698   {
11699     try {
11700       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
11701     } catch (std::out_of_range& e) {
11702       {
11703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11704       };
11705     } catch (std::exception& e) {
11706       {
11707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11708       };
11709     } catch (...) {
11710       {
11711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11712       };
11713     }
11714   }
11715   jresult = result;
11716   return jresult;
11717 }
11718
11719
11720 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
11721   unsigned int jresult ;
11722   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11723   Dali::Matrix *arg2 = 0 ;
11724   bool result;
11725
11726   arg1 = (Dali::Matrix *)jarg1;
11727   arg2 = (Dali::Matrix *)jarg2;
11728   if (!arg2) {
11729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11730     return 0;
11731   }
11732   {
11733     try {
11734       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
11735     } catch (std::out_of_range& e) {
11736       {
11737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11738       };
11739     } catch (std::exception& e) {
11740       {
11741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11742       };
11743     } catch (...) {
11744       {
11745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11746       };
11747     }
11748   }
11749   jresult = result;
11750   return jresult;
11751 }
11752
11753
11754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11755   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11756   Dali::Vector3 *arg2 = 0 ;
11757   Dali::Quaternion *arg3 = 0 ;
11758   Dali::Vector3 *arg4 = 0 ;
11759
11760   arg1 = (Dali::Matrix *)jarg1;
11761   arg2 = (Dali::Vector3 *)jarg2;
11762   if (!arg2) {
11763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11764     return ;
11765   }
11766   arg3 = (Dali::Quaternion *)jarg3;
11767   if (!arg3) {
11768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11769     return ;
11770   }
11771   arg4 = (Dali::Vector3 *)jarg4;
11772   if (!arg4) {
11773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11774     return ;
11775   }
11776   {
11777     try {
11778       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11779     } catch (std::out_of_range& e) {
11780       {
11781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11782       };
11783     } catch (std::exception& e) {
11784       {
11785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11786       };
11787     } catch (...) {
11788       {
11789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11790       };
11791     }
11792   }
11793 }
11794
11795
11796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11797   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11798   Dali::Vector3 *arg2 = 0 ;
11799   Dali::Quaternion *arg3 = 0 ;
11800   Dali::Vector3 *arg4 = 0 ;
11801
11802   arg1 = (Dali::Matrix *)jarg1;
11803   arg2 = (Dali::Vector3 *)jarg2;
11804   if (!arg2) {
11805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11806     return ;
11807   }
11808   arg3 = (Dali::Quaternion *)jarg3;
11809   if (!arg3) {
11810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11811     return ;
11812   }
11813   arg4 = (Dali::Vector3 *)jarg4;
11814   if (!arg4) {
11815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11816     return ;
11817   }
11818   {
11819     try {
11820       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11821     } catch (std::out_of_range& e) {
11822       {
11823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11824       };
11825     } catch (std::exception& e) {
11826       {
11827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11828       };
11829     } catch (...) {
11830       {
11831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11832       };
11833     }
11834   }
11835 }
11836
11837
11838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
11839   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11840   Dali::Vector3 *arg2 = 0 ;
11841   Dali::Vector3 *arg3 = 0 ;
11842   Dali::Vector3 *arg4 = 0 ;
11843   Dali::Vector3 *arg5 = 0 ;
11844
11845   arg1 = (Dali::Matrix *)jarg1;
11846   arg2 = (Dali::Vector3 *)jarg2;
11847   if (!arg2) {
11848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11849     return ;
11850   }
11851   arg3 = (Dali::Vector3 *)jarg3;
11852   if (!arg3) {
11853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11854     return ;
11855   }
11856   arg4 = (Dali::Vector3 *)jarg4;
11857   if (!arg4) {
11858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11859     return ;
11860   }
11861   arg5 = (Dali::Vector3 *)jarg5;
11862   if (!arg5) {
11863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11864     return ;
11865   }
11866   {
11867     try {
11868       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
11869     } catch (std::out_of_range& e) {
11870       {
11871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11872       };
11873     } catch (std::exception& e) {
11874       {
11875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11876       };
11877     } catch (...) {
11878       {
11879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11880       };
11881     }
11882   }
11883 }
11884
11885
11886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11887   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11888   Dali::Vector3 *arg2 = 0 ;
11889   Dali::Quaternion *arg3 = 0 ;
11890   Dali::Vector3 *arg4 = 0 ;
11891
11892   arg1 = (Dali::Matrix *)jarg1;
11893   arg2 = (Dali::Vector3 *)jarg2;
11894   if (!arg2) {
11895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11896     return ;
11897   }
11898   arg3 = (Dali::Quaternion *)jarg3;
11899   if (!arg3) {
11900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
11901     return ;
11902   }
11903   arg4 = (Dali::Vector3 *)jarg4;
11904   if (!arg4) {
11905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11906     return ;
11907   }
11908   {
11909     try {
11910       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
11911     } catch (std::out_of_range& e) {
11912       {
11913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11914       };
11915     } catch (std::exception& e) {
11916       {
11917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11918       };
11919     } catch (...) {
11920       {
11921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11922       };
11923     }
11924   }
11925 }
11926
11927
11928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
11929   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11930
11931   arg1 = (Dali::Matrix *)jarg1;
11932   {
11933     try {
11934       delete arg1;
11935     } catch (std::out_of_range& e) {
11936       {
11937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11938       };
11939     } catch (std::exception& e) {
11940       {
11941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11942       };
11943     } catch (...) {
11944       {
11945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11946       };
11947     }
11948   }
11949 }
11950
11951
11952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
11953   void * jresult ;
11954   Dali::Matrix3 *result = 0 ;
11955
11956   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
11957   jresult = (void *)result;
11958   return jresult;
11959 }
11960
11961
11962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
11963   void * jresult ;
11964   Dali::Matrix3 *result = 0 ;
11965
11966   {
11967     try {
11968       result = (Dali::Matrix3 *)new Dali::Matrix3();
11969     } catch (std::out_of_range& e) {
11970       {
11971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11972       };
11973     } catch (std::exception& e) {
11974       {
11975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11976       };
11977     } catch (...) {
11978       {
11979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11980       };
11981     }
11982   }
11983   jresult = (void *)result;
11984   return jresult;
11985 }
11986
11987
11988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
11989   void * jresult ;
11990   Dali::Matrix3 *arg1 = 0 ;
11991   Dali::Matrix3 *result = 0 ;
11992
11993   arg1 = (Dali::Matrix3 *)jarg1;
11994   if (!arg1) {
11995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
11996     return 0;
11997   }
11998   {
11999     try {
12000       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
12001     } catch (std::out_of_range& e) {
12002       {
12003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12004       };
12005     } catch (std::exception& e) {
12006       {
12007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12008       };
12009     } catch (...) {
12010       {
12011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12012       };
12013     }
12014   }
12015   jresult = (void *)result;
12016   return jresult;
12017 }
12018
12019
12020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
12021   void * jresult ;
12022   Dali::Matrix *arg1 = 0 ;
12023   Dali::Matrix3 *result = 0 ;
12024
12025   arg1 = (Dali::Matrix *)jarg1;
12026   if (!arg1) {
12027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12028     return 0;
12029   }
12030   {
12031     try {
12032       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
12033     } catch (std::out_of_range& e) {
12034       {
12035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12036       };
12037     } catch (std::exception& e) {
12038       {
12039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12040       };
12041     } catch (...) {
12042       {
12043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12044       };
12045     }
12046   }
12047   jresult = (void *)result;
12048   return jresult;
12049 }
12050
12051
12052 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) {
12053   void * jresult ;
12054   float arg1 ;
12055   float arg2 ;
12056   float arg3 ;
12057   float arg4 ;
12058   float arg5 ;
12059   float arg6 ;
12060   float arg7 ;
12061   float arg8 ;
12062   float arg9 ;
12063   Dali::Matrix3 *result = 0 ;
12064
12065   arg1 = (float)jarg1;
12066   arg2 = (float)jarg2;
12067   arg3 = (float)jarg3;
12068   arg4 = (float)jarg4;
12069   arg5 = (float)jarg5;
12070   arg6 = (float)jarg6;
12071   arg7 = (float)jarg7;
12072   arg8 = (float)jarg8;
12073   arg9 = (float)jarg9;
12074   {
12075     try {
12076       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
12077     } catch (std::out_of_range& e) {
12078       {
12079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12080       };
12081     } catch (std::exception& e) {
12082       {
12083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12084       };
12085     } catch (...) {
12086       {
12087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12088       };
12089     }
12090   }
12091   jresult = (void *)result;
12092   return jresult;
12093 }
12094
12095
12096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
12097   void * jresult ;
12098   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12099   Dali::Matrix3 *arg2 = 0 ;
12100   Dali::Matrix3 *result = 0 ;
12101
12102   arg1 = (Dali::Matrix3 *)jarg1;
12103   arg2 = (Dali::Matrix3 *)jarg2;
12104   if (!arg2) {
12105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12106     return 0;
12107   }
12108   {
12109     try {
12110       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
12111     } catch (std::out_of_range& e) {
12112       {
12113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12114       };
12115     } catch (std::exception& e) {
12116       {
12117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12118       };
12119     } catch (...) {
12120       {
12121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12122       };
12123     }
12124   }
12125   jresult = (void *)result;
12126   return jresult;
12127 }
12128
12129
12130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
12131   void * jresult ;
12132   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12133   Dali::Matrix *arg2 = 0 ;
12134   Dali::Matrix3 *result = 0 ;
12135
12136   arg1 = (Dali::Matrix3 *)jarg1;
12137   arg2 = (Dali::Matrix *)jarg2;
12138   if (!arg2) {
12139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12140     return 0;
12141   }
12142   {
12143     try {
12144       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12145     } catch (std::out_of_range& e) {
12146       {
12147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12148       };
12149     } catch (std::exception& e) {
12150       {
12151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12152       };
12153     } catch (...) {
12154       {
12155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12156       };
12157     }
12158   }
12159   jresult = (void *)result;
12160   return jresult;
12161 }
12162
12163
12164 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
12165   unsigned int jresult ;
12166   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12167   Dali::Matrix3 *arg2 = 0 ;
12168   bool result;
12169
12170   arg1 = (Dali::Matrix3 *)jarg1;
12171   arg2 = (Dali::Matrix3 *)jarg2;
12172   if (!arg2) {
12173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12174     return 0;
12175   }
12176   {
12177     try {
12178       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
12179     } catch (std::out_of_range& e) {
12180       {
12181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12182       };
12183     } catch (std::exception& e) {
12184       {
12185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12186       };
12187     } catch (...) {
12188       {
12189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12190       };
12191     }
12192   }
12193   jresult = result;
12194   return jresult;
12195 }
12196
12197
12198 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
12199   unsigned int jresult ;
12200   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12201   Dali::Matrix3 *arg2 = 0 ;
12202   bool result;
12203
12204   arg1 = (Dali::Matrix3 *)jarg1;
12205   arg2 = (Dali::Matrix3 *)jarg2;
12206   if (!arg2) {
12207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12208     return 0;
12209   }
12210   {
12211     try {
12212       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
12213     } catch (std::out_of_range& e) {
12214       {
12215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12216       };
12217     } catch (std::exception& e) {
12218       {
12219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12220       };
12221     } catch (...) {
12222       {
12223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12224       };
12225     }
12226   }
12227   jresult = result;
12228   return jresult;
12229 }
12230
12231
12232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
12233   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12234
12235   arg1 = (Dali::Matrix3 *)jarg1;
12236   {
12237     try {
12238       delete arg1;
12239     } catch (std::out_of_range& e) {
12240       {
12241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12242       };
12243     } catch (std::exception& e) {
12244       {
12245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12246       };
12247     } catch (...) {
12248       {
12249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12250       };
12251     }
12252   }
12253 }
12254
12255
12256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
12257   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12258
12259   arg1 = (Dali::Matrix3 *)jarg1;
12260   {
12261     try {
12262       (arg1)->SetIdentity();
12263     } catch (std::out_of_range& e) {
12264       {
12265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12266       };
12267     } catch (std::exception& e) {
12268       {
12269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12270       };
12271     } catch (...) {
12272       {
12273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12274       };
12275     }
12276   }
12277 }
12278
12279
12280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
12281   void * jresult ;
12282   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12283   float *result = 0 ;
12284
12285   arg1 = (Dali::Matrix3 *)jarg1;
12286   {
12287     try {
12288       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
12289     } catch (std::out_of_range& e) {
12290       {
12291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12292       };
12293     } catch (std::exception& e) {
12294       {
12295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12296       };
12297     } catch (...) {
12298       {
12299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12300       };
12301     }
12302   }
12303   jresult = (void *)result;
12304   return jresult;
12305 }
12306
12307
12308 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
12309   unsigned int jresult ;
12310   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12311   bool result;
12312
12313   arg1 = (Dali::Matrix3 *)jarg1;
12314   {
12315     try {
12316       result = (bool)(arg1)->Invert();
12317     } catch (std::out_of_range& e) {
12318       {
12319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12320       };
12321     } catch (std::exception& e) {
12322       {
12323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12324       };
12325     } catch (...) {
12326       {
12327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12328       };
12329     }
12330   }
12331   jresult = result;
12332   return jresult;
12333 }
12334
12335
12336 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
12337   unsigned int jresult ;
12338   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12339   bool result;
12340
12341   arg1 = (Dali::Matrix3 *)jarg1;
12342   {
12343     try {
12344       result = (bool)(arg1)->Transpose();
12345     } catch (std::out_of_range& e) {
12346       {
12347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12348       };
12349     } catch (std::exception& e) {
12350       {
12351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12352       };
12353     } catch (...) {
12354       {
12355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12356       };
12357     }
12358   }
12359   jresult = result;
12360   return jresult;
12361 }
12362
12363
12364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
12365   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12366   float arg2 ;
12367
12368   arg1 = (Dali::Matrix3 *)jarg1;
12369   arg2 = (float)jarg2;
12370   {
12371     try {
12372       (arg1)->Scale(arg2);
12373     } catch (std::out_of_range& e) {
12374       {
12375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12376       };
12377     } catch (std::exception& e) {
12378       {
12379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12380       };
12381     } catch (...) {
12382       {
12383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12384       };
12385     }
12386   }
12387 }
12388
12389
12390 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
12391   float jresult ;
12392   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12393   float result;
12394
12395   arg1 = (Dali::Matrix3 *)jarg1;
12396   {
12397     try {
12398       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
12399     } catch (std::out_of_range& e) {
12400       {
12401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12402       };
12403     } catch (std::exception& e) {
12404       {
12405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12406       };
12407     } catch (...) {
12408       {
12409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12410       };
12411     }
12412   }
12413   jresult = result;
12414   return jresult;
12415 }
12416
12417
12418 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
12419   unsigned int jresult ;
12420   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12421   bool result;
12422
12423   arg1 = (Dali::Matrix3 *)jarg1;
12424   {
12425     try {
12426       result = (bool)(arg1)->ScaledInverseTranspose();
12427     } catch (std::out_of_range& e) {
12428       {
12429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12430       };
12431     } catch (std::exception& e) {
12432       {
12433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12434       };
12435     } catch (...) {
12436       {
12437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12438       };
12439     }
12440   }
12441   jresult = result;
12442   return jresult;
12443 }
12444
12445
12446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
12447   Dali::Matrix3 *arg1 = 0 ;
12448   Dali::Matrix3 *arg2 = 0 ;
12449   Dali::Matrix3 *arg3 = 0 ;
12450
12451   arg1 = (Dali::Matrix3 *)jarg1;
12452   if (!arg1) {
12453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
12454     return ;
12455   }
12456   arg2 = (Dali::Matrix3 *)jarg2;
12457   if (!arg2) {
12458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12459     return ;
12460   }
12461   arg3 = (Dali::Matrix3 *)jarg3;
12462   if (!arg3) {
12463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12464     return ;
12465   }
12466   {
12467     try {
12468       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
12469     } catch (std::out_of_range& e) {
12470       {
12471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12472       };
12473     } catch (std::exception& e) {
12474       {
12475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12476       };
12477     } catch (...) {
12478       {
12479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12480       };
12481     }
12482   }
12483 }
12484
12485
12486 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
12487   float jresult ;
12488   float arg1 ;
12489   float arg2 ;
12490   float result;
12491
12492   arg1 = (float)jarg1;
12493   arg2 = (float)jarg2;
12494   {
12495     try {
12496       result = (float)Dali::Random::Range(arg1,arg2);
12497     } catch (std::out_of_range& e) {
12498       {
12499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12500       };
12501     } catch (std::exception& e) {
12502       {
12503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12504       };
12505     } catch (...) {
12506       {
12507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12508       };
12509     }
12510   }
12511   jresult = result;
12512   return jresult;
12513 }
12514
12515
12516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
12517   void * jresult ;
12518   Dali::Vector4 result;
12519
12520   {
12521     try {
12522       result = Dali::Random::Axis();
12523     } catch (std::out_of_range& e) {
12524       {
12525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12526       };
12527     } catch (std::exception& e) {
12528       {
12529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12530       };
12531     } catch (...) {
12532       {
12533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12534       };
12535     }
12536   }
12537   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
12538   return jresult;
12539 }
12540
12541
12542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
12543   void * jresult ;
12544   Dali::AngleAxis *result = 0 ;
12545
12546   {
12547     try {
12548       result = (Dali::AngleAxis *)new Dali::AngleAxis();
12549     } catch (std::out_of_range& e) {
12550       {
12551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12552       };
12553     } catch (std::exception& e) {
12554       {
12555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12556       };
12557     } catch (...) {
12558       {
12559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12560       };
12561     }
12562   }
12563   jresult = (void *)result;
12564   return jresult;
12565 }
12566
12567
12568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
12569   void * jresult ;
12570   Dali::Radian arg1 ;
12571   Dali::Vector3 *arg2 = 0 ;
12572   Dali::Radian *argp1 ;
12573   Dali::AngleAxis *result = 0 ;
12574
12575   argp1 = (Dali::Radian *)jarg1;
12576   if (!argp1) {
12577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
12578     return 0;
12579   }
12580   arg1 = *argp1;
12581   arg2 = (Dali::Vector3 *)jarg2;
12582   if (!arg2) {
12583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12584     return 0;
12585   }
12586   {
12587     try {
12588       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
12589     } catch (std::out_of_range& e) {
12590       {
12591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12592       };
12593     } catch (std::exception& e) {
12594       {
12595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12596       };
12597     } catch (...) {
12598       {
12599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12600       };
12601     }
12602   }
12603   jresult = (void *)result;
12604   return jresult;
12605 }
12606
12607
12608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
12609   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12610   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
12611
12612   arg1 = (Dali::AngleAxis *)jarg1;
12613   arg2 = (Dali::Radian *)jarg2;
12614   if (arg1) (arg1)->angle = *arg2;
12615 }
12616
12617
12618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
12619   void * jresult ;
12620   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12621   Dali::Radian *result = 0 ;
12622
12623   arg1 = (Dali::AngleAxis *)jarg1;
12624   result = (Dali::Radian *)& ((arg1)->angle);
12625   jresult = (void *)result;
12626   return jresult;
12627 }
12628
12629
12630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
12631   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12632   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
12633
12634   arg1 = (Dali::AngleAxis *)jarg1;
12635   arg2 = (Dali::Vector3 *)jarg2;
12636   if (arg1) (arg1)->axis = *arg2;
12637 }
12638
12639
12640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
12641   void * jresult ;
12642   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12643   Dali::Vector3 *result = 0 ;
12644
12645   arg1 = (Dali::AngleAxis *)jarg1;
12646   result = (Dali::Vector3 *)& ((arg1)->axis);
12647   jresult = (void *)result;
12648   return jresult;
12649 }
12650
12651
12652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
12653   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12654
12655   arg1 = (Dali::AngleAxis *)jarg1;
12656   {
12657     try {
12658       delete arg1;
12659     } catch (std::out_of_range& e) {
12660       {
12661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12662       };
12663     } catch (std::exception& e) {
12664       {
12665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12666       };
12667     } catch (...) {
12668       {
12669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12670       };
12671     }
12672   }
12673 }
12674
12675
12676 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
12677   unsigned int jresult ;
12678   Dali::AngleAxis *arg1 = 0 ;
12679   Dali::AngleAxis *arg2 = 0 ;
12680   bool result;
12681
12682   arg1 = (Dali::AngleAxis *)jarg1;
12683   if (!arg1) {
12684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12685     return 0;
12686   }
12687   arg2 = (Dali::AngleAxis *)jarg2;
12688   if (!arg2) {
12689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12690     return 0;
12691   }
12692   {
12693     try {
12694       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
12695     } catch (std::out_of_range& e) {
12696       {
12697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12698       };
12699     } catch (std::exception& e) {
12700       {
12701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12702       };
12703     } catch (...) {
12704       {
12705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12706       };
12707     }
12708   }
12709   jresult = result;
12710   return jresult;
12711 }
12712
12713
12714 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
12715   unsigned int jresult ;
12716   unsigned int arg1 ;
12717   unsigned int result;
12718
12719   arg1 = (unsigned int)jarg1;
12720   {
12721     try {
12722       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
12723     } catch (std::out_of_range& e) {
12724       {
12725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12726       };
12727     } catch (std::exception& e) {
12728       {
12729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12730       };
12731     } catch (...) {
12732       {
12733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12734       };
12735     }
12736   }
12737   jresult = result;
12738   return jresult;
12739 }
12740
12741
12742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
12743   unsigned int jresult ;
12744   unsigned int arg1 ;
12745   bool result;
12746
12747   arg1 = (unsigned int)jarg1;
12748   {
12749     try {
12750       result = (bool)Dali::IsPowerOfTwo(arg1);
12751     } catch (std::out_of_range& e) {
12752       {
12753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12754       };
12755     } catch (std::exception& e) {
12756       {
12757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12758       };
12759     } catch (...) {
12760       {
12761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12762       };
12763     }
12764   }
12765   jresult = result;
12766   return jresult;
12767 }
12768
12769
12770 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
12771   float jresult ;
12772   float arg1 ;
12773   float arg2 ;
12774   float result;
12775
12776   arg1 = (float)jarg1;
12777   arg2 = (float)jarg2;
12778   {
12779     try {
12780       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
12781     } catch (std::out_of_range& e) {
12782       {
12783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12784       };
12785     } catch (std::exception& e) {
12786       {
12787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12788       };
12789     } catch (...) {
12790       {
12791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12792       };
12793     }
12794   }
12795   jresult = result;
12796   return jresult;
12797 }
12798
12799
12800 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
12801   unsigned int jresult ;
12802   float arg1 ;
12803   bool result;
12804
12805   arg1 = (float)jarg1;
12806   {
12807     try {
12808       result = (bool)Dali::EqualsZero(arg1);
12809     } catch (std::out_of_range& e) {
12810       {
12811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12812       };
12813     } catch (std::exception& e) {
12814       {
12815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12816       };
12817     } catch (...) {
12818       {
12819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12820       };
12821     }
12822   }
12823   jresult = result;
12824   return jresult;
12825 }
12826
12827
12828 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
12829   unsigned int jresult ;
12830   float arg1 ;
12831   float arg2 ;
12832   bool result;
12833
12834   arg1 = (float)jarg1;
12835   arg2 = (float)jarg2;
12836   {
12837     try {
12838       result = (bool)Dali::Equals(arg1,arg2);
12839     } catch (std::out_of_range& e) {
12840       {
12841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12842       };
12843     } catch (std::exception& e) {
12844       {
12845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12846       };
12847     } catch (...) {
12848       {
12849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12850       };
12851     }
12852   }
12853   jresult = result;
12854   return jresult;
12855 }
12856
12857
12858 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
12859   unsigned int jresult ;
12860   float arg1 ;
12861   float arg2 ;
12862   float arg3 ;
12863   bool result;
12864
12865   arg1 = (float)jarg1;
12866   arg2 = (float)jarg2;
12867   arg3 = (float)jarg3;
12868   {
12869     try {
12870       result = (bool)Dali::Equals(arg1,arg2,arg3);
12871     } catch (std::out_of_range& e) {
12872       {
12873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12874       };
12875     } catch (std::exception& e) {
12876       {
12877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12878       };
12879     } catch (...) {
12880       {
12881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12882       };
12883     }
12884   }
12885   jresult = result;
12886   return jresult;
12887 }
12888
12889
12890 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
12891   float jresult ;
12892   float arg1 ;
12893   int arg2 ;
12894   float result;
12895
12896   arg1 = (float)jarg1;
12897   arg2 = (int)jarg2;
12898   {
12899     try {
12900       result = (float)Dali::Round(arg1,arg2);
12901     } catch (std::out_of_range& e) {
12902       {
12903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12904       };
12905     } catch (std::exception& e) {
12906       {
12907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12908       };
12909     } catch (...) {
12910       {
12911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12912       };
12913     }
12914   }
12915   jresult = result;
12916   return jresult;
12917 }
12918
12919
12920 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
12921   float jresult ;
12922   float arg1 ;
12923   float arg2 ;
12924   float arg3 ;
12925   float result;
12926
12927   arg1 = (float)jarg1;
12928   arg2 = (float)jarg2;
12929   arg3 = (float)jarg3;
12930   {
12931     try {
12932       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
12933     } catch (std::out_of_range& e) {
12934       {
12935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12936       };
12937     } catch (std::exception& e) {
12938       {
12939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12940       };
12941     } catch (...) {
12942       {
12943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12944       };
12945     }
12946   }
12947   jresult = result;
12948   return jresult;
12949 }
12950
12951
12952 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
12953   float jresult ;
12954   float arg1 ;
12955   float arg2 ;
12956   float arg3 ;
12957   float arg4 ;
12958   float result;
12959
12960   arg1 = (float)jarg1;
12961   arg2 = (float)jarg2;
12962   arg3 = (float)jarg3;
12963   arg4 = (float)jarg4;
12964   {
12965     try {
12966       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
12967     } catch (std::out_of_range& e) {
12968       {
12969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12970       };
12971     } catch (std::exception& e) {
12972       {
12973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12974       };
12975     } catch (...) {
12976       {
12977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12978       };
12979     }
12980   }
12981   jresult = result;
12982   return jresult;
12983 }
12984
12985
12986 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
12987   int jresult ;
12988   int result;
12989
12990   result = (int)(int)Dali::Property::INVALID_INDEX;
12991   jresult = result;
12992   return jresult;
12993 }
12994
12995
12996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
12997   int jresult ;
12998   int result;
12999
13000   result = (int)(int)Dali::Property::INVALID_KEY;
13001   jresult = result;
13002   return jresult;
13003 }
13004
13005
13006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
13007   int jresult ;
13008   int result;
13009
13010   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
13011   jresult = result;
13012   return jresult;
13013 }
13014
13015
13016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
13017   void * jresult ;
13018   Dali::Handle *arg1 = 0 ;
13019   Dali::Property::Index arg2 ;
13020   Dali::Property *result = 0 ;
13021
13022   arg1 = (Dali::Handle *)jarg1;
13023   if (!arg1) {
13024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13025     return 0;
13026   }
13027   arg2 = (Dali::Property::Index)jarg2;
13028   {
13029     try {
13030       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
13031     } catch (std::out_of_range& e) {
13032       {
13033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13034       };
13035     } catch (std::exception& e) {
13036       {
13037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13038       };
13039     } catch (...) {
13040       {
13041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13042       };
13043     }
13044   }
13045   jresult = (void *)result;
13046   return jresult;
13047 }
13048
13049
13050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
13051   void * jresult ;
13052   Dali::Handle *arg1 = 0 ;
13053   Dali::Property::Index arg2 ;
13054   int arg3 ;
13055   Dali::Property *result = 0 ;
13056
13057   arg1 = (Dali::Handle *)jarg1;
13058   if (!arg1) {
13059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13060     return 0;
13061   }
13062   arg2 = (Dali::Property::Index)jarg2;
13063   arg3 = (int)jarg3;
13064   {
13065     try {
13066       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
13067     } catch (std::out_of_range& e) {
13068       {
13069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13070       };
13071     } catch (std::exception& e) {
13072       {
13073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13074       };
13075     } catch (...) {
13076       {
13077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13078       };
13079     }
13080   }
13081   jresult = (void *)result;
13082   return jresult;
13083 }
13084
13085
13086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
13087   void * jresult ;
13088   Dali::Handle *arg1 = 0 ;
13089   std::string *arg2 = 0 ;
13090   Dali::Property *result = 0 ;
13091
13092   arg1 = (Dali::Handle *)jarg1;
13093   if (!arg1) {
13094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13095     return 0;
13096   }
13097   if (!jarg2) {
13098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13099     return 0;
13100   }
13101   std::string arg2_str(jarg2);
13102   arg2 = &arg2_str;
13103   {
13104     try {
13105       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
13106     } catch (std::out_of_range& e) {
13107       {
13108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13109       };
13110     } catch (std::exception& e) {
13111       {
13112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13113       };
13114     } catch (...) {
13115       {
13116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13117       };
13118     }
13119   }
13120   jresult = (void *)result;
13121
13122   //argout typemap for const std::string&
13123
13124   return jresult;
13125 }
13126
13127
13128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
13129   void * jresult ;
13130   Dali::Handle *arg1 = 0 ;
13131   std::string *arg2 = 0 ;
13132   int arg3 ;
13133   Dali::Property *result = 0 ;
13134
13135   arg1 = (Dali::Handle *)jarg1;
13136   if (!arg1) {
13137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13138     return 0;
13139   }
13140   if (!jarg2) {
13141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13142     return 0;
13143   }
13144   std::string arg2_str(jarg2);
13145   arg2 = &arg2_str;
13146   arg3 = (int)jarg3;
13147   {
13148     try {
13149       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
13150     } catch (std::out_of_range& e) {
13151       {
13152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13153       };
13154     } catch (std::exception& e) {
13155       {
13156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13157       };
13158     } catch (...) {
13159       {
13160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13161       };
13162     }
13163   }
13164   jresult = (void *)result;
13165
13166   //argout typemap for const std::string&
13167
13168   return jresult;
13169 }
13170
13171
13172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
13173   Dali::Property *arg1 = (Dali::Property *) 0 ;
13174
13175   arg1 = (Dali::Property *)jarg1;
13176   {
13177     try {
13178       delete arg1;
13179     } catch (std::out_of_range& e) {
13180       {
13181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13182       };
13183     } catch (std::exception& e) {
13184       {
13185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13186       };
13187     } catch (...) {
13188       {
13189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13190       };
13191     }
13192   }
13193 }
13194
13195
13196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
13197   Dali::Property *arg1 = (Dali::Property *) 0 ;
13198   Dali::Handle *arg2 = 0 ;
13199
13200   arg1 = (Dali::Property *)jarg1;
13201   arg2 = (Dali::Handle *)jarg2;
13202   if (!arg2) {
13203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13204     return ;
13205   }
13206   if (arg1) (arg1)->object = *arg2;
13207 }
13208
13209
13210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
13211   void * jresult ;
13212   Dali::Property *arg1 = (Dali::Property *) 0 ;
13213   Dali::Handle *result = 0 ;
13214
13215   arg1 = (Dali::Property *)jarg1;
13216   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
13217   jresult = (void *)result;
13218   return jresult;
13219 }
13220
13221
13222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
13223   Dali::Property *arg1 = (Dali::Property *) 0 ;
13224   Dali::Property::Index arg2 ;
13225
13226   arg1 = (Dali::Property *)jarg1;
13227   arg2 = (Dali::Property::Index)jarg2;
13228   if (arg1) (arg1)->propertyIndex = arg2;
13229 }
13230
13231
13232 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
13233   int jresult ;
13234   Dali::Property *arg1 = (Dali::Property *) 0 ;
13235   Dali::Property::Index result;
13236
13237   arg1 = (Dali::Property *)jarg1;
13238   result = (Dali::Property::Index) ((arg1)->propertyIndex);
13239   jresult = result;
13240   return jresult;
13241 }
13242
13243
13244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
13245   Dali::Property *arg1 = (Dali::Property *) 0 ;
13246   int arg2 ;
13247
13248   arg1 = (Dali::Property *)jarg1;
13249   arg2 = (int)jarg2;
13250   if (arg1) (arg1)->componentIndex = arg2;
13251 }
13252
13253
13254 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
13255   int jresult ;
13256   Dali::Property *arg1 = (Dali::Property *) 0 ;
13257   int result;
13258
13259   arg1 = (Dali::Property *)jarg1;
13260   result = (int) ((arg1)->componentIndex);
13261   jresult = result;
13262   return jresult;
13263 }
13264
13265
13266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
13267   void * jresult ;
13268   Dali::Property::Array *result = 0 ;
13269
13270   {
13271     try {
13272       result = (Dali::Property::Array *)new Dali::Property::Array();
13273     } catch (std::out_of_range& e) {
13274       {
13275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13276       };
13277     } catch (std::exception& e) {
13278       {
13279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13280       };
13281     } catch (...) {
13282       {
13283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13284       };
13285     }
13286   }
13287   jresult = (void *)result;
13288   return jresult;
13289 }
13290
13291
13292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
13293   void * jresult ;
13294   Dali::Property::Array *arg1 = 0 ;
13295   Dali::Property::Array *result = 0 ;
13296
13297   arg1 = (Dali::Property::Array *)jarg1;
13298   if (!arg1) {
13299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13300     return 0;
13301   }
13302   {
13303     try {
13304       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
13305     } catch (std::out_of_range& e) {
13306       {
13307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13308       };
13309     } catch (std::exception& e) {
13310       {
13311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13312       };
13313     } catch (...) {
13314       {
13315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13316       };
13317     }
13318   }
13319   jresult = (void *)result;
13320   return jresult;
13321 }
13322
13323
13324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
13325   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13326
13327   arg1 = (Dali::Property::Array *)jarg1;
13328   {
13329     try {
13330       delete arg1;
13331     } catch (std::out_of_range& e) {
13332       {
13333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13334       };
13335     } catch (std::exception& e) {
13336       {
13337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13338       };
13339     } catch (...) {
13340       {
13341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13342       };
13343     }
13344   }
13345 }
13346
13347
13348 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
13349   unsigned long jresult ;
13350   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13351   Dali::Property::Array::SizeType result;
13352
13353   arg1 = (Dali::Property::Array *)jarg1;
13354   {
13355     try {
13356       result = ((Dali::Property::Array const *)arg1)->Size();
13357     } catch (std::out_of_range& e) {
13358       {
13359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13360       };
13361     } catch (std::exception& e) {
13362       {
13363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13364       };
13365     } catch (...) {
13366       {
13367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13368       };
13369     }
13370   }
13371   jresult = (unsigned long)result;
13372   return jresult;
13373 }
13374
13375
13376 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
13377   unsigned long jresult ;
13378   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13379   Dali::Property::Array::SizeType result;
13380
13381   arg1 = (Dali::Property::Array *)jarg1;
13382   {
13383     try {
13384       result = ((Dali::Property::Array const *)arg1)->Count();
13385     } catch (std::out_of_range& e) {
13386       {
13387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13388       };
13389     } catch (std::exception& e) {
13390       {
13391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13392       };
13393     } catch (...) {
13394       {
13395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13396       };
13397     }
13398   }
13399   jresult = (unsigned long)result;
13400   return jresult;
13401 }
13402
13403
13404 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
13405   unsigned int jresult ;
13406   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13407   bool result;
13408
13409   arg1 = (Dali::Property::Array *)jarg1;
13410   {
13411     try {
13412       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
13413     } catch (std::out_of_range& e) {
13414       {
13415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13416       };
13417     } catch (std::exception& e) {
13418       {
13419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13420       };
13421     } catch (...) {
13422       {
13423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13424       };
13425     }
13426   }
13427   jresult = result;
13428   return jresult;
13429 }
13430
13431
13432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
13433   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13434
13435   arg1 = (Dali::Property::Array *)jarg1;
13436   {
13437     try {
13438       (arg1)->Clear();
13439     } catch (std::out_of_range& e) {
13440       {
13441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13442       };
13443     } catch (std::exception& e) {
13444       {
13445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13446       };
13447     } catch (...) {
13448       {
13449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13450       };
13451     }
13452   }
13453 }
13454
13455
13456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
13457   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13458   Dali::Property::Array::SizeType arg2 ;
13459
13460   arg1 = (Dali::Property::Array *)jarg1;
13461   arg2 = (Dali::Property::Array::SizeType)jarg2;
13462   {
13463     try {
13464       (arg1)->Reserve(arg2);
13465     } catch (std::out_of_range& e) {
13466       {
13467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13468       };
13469     } catch (std::exception& e) {
13470       {
13471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13472       };
13473     } catch (...) {
13474       {
13475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13476       };
13477     }
13478   }
13479 }
13480
13481
13482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
13483   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13484   Dali::Property::Array::SizeType arg2 ;
13485
13486   arg1 = (Dali::Property::Array *)jarg1;
13487   arg2 = (Dali::Property::Array::SizeType)jarg2;
13488   {
13489     try {
13490       (arg1)->Resize(arg2);
13491     } catch (std::out_of_range& e) {
13492       {
13493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13494       };
13495     } catch (std::exception& e) {
13496       {
13497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13498       };
13499     } catch (...) {
13500       {
13501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13502       };
13503     }
13504   }
13505 }
13506
13507
13508 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
13509   unsigned long jresult ;
13510   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13511   Dali::Property::Array::SizeType result;
13512
13513   arg1 = (Dali::Property::Array *)jarg1;
13514   {
13515     try {
13516       result = (arg1)->Capacity();
13517     } catch (std::out_of_range& e) {
13518       {
13519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13520       };
13521     } catch (std::exception& e) {
13522       {
13523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13524       };
13525     } catch (...) {
13526       {
13527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13528       };
13529     }
13530   }
13531   jresult = (unsigned long)result;
13532   return jresult;
13533 }
13534
13535
13536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
13537   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13538   Dali::Property::Value *arg2 = 0 ;
13539
13540   arg1 = (Dali::Property::Array *)jarg1;
13541   arg2 = (Dali::Property::Value *)jarg2;
13542   if (!arg2) {
13543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13544     return ;
13545   }
13546   {
13547     try {
13548       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
13549     } catch (std::out_of_range& e) {
13550       {
13551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13552       };
13553     } catch (std::exception& e) {
13554       {
13555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13556       };
13557     } catch (...) {
13558       {
13559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13560       };
13561     }
13562   }
13563 }
13564
13565
13566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
13567   void * jresult ;
13568   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13569   Dali::Property::Value *arg2 = 0 ;
13570   Dali::Property::Array *result = 0 ;
13571
13572   arg1 = (Dali::Property::Array *)jarg1;
13573   arg2 = (Dali::Property::Value *)jarg2;
13574   if (!arg2) {
13575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13576     return 0;
13577   }
13578   {
13579     try {
13580       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
13581     } catch (std::out_of_range& e) {
13582       {
13583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13584       };
13585     } catch (std::exception& e) {
13586       {
13587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13588       };
13589     } catch (...) {
13590       {
13591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13592       };
13593     }
13594   }
13595   jresult = (void *)result;
13596   return jresult;
13597 }
13598
13599
13600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
13601   void * jresult ;
13602   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13603   Dali::Property::Array::SizeType arg2 ;
13604   Dali::Property::Value *result = 0 ;
13605
13606   arg1 = (Dali::Property::Array *)jarg1;
13607   arg2 = (Dali::Property::Array::SizeType)jarg2;
13608   {
13609     try {
13610       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
13611     } catch (std::out_of_range& e) {
13612       {
13613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13614       };
13615     } catch (std::exception& e) {
13616       {
13617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13618       };
13619     } catch (...) {
13620       {
13621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13622       };
13623     }
13624   }
13625   jresult = (void *)result;
13626   return jresult;
13627 }
13628
13629
13630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
13631   void * jresult ;
13632   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13633   Dali::Property::Array::SizeType arg2 ;
13634   Dali::Property::Value *result = 0 ;
13635
13636   arg1 = (Dali::Property::Array *)jarg1;
13637   arg2 = (Dali::Property::Array::SizeType)jarg2;
13638   {
13639     try {
13640       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
13641     } catch (std::out_of_range& e) {
13642       {
13643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13644       };
13645     } catch (std::exception& e) {
13646       {
13647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13648       };
13649     } catch (...) {
13650       {
13651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13652       };
13653     }
13654   }
13655   jresult = (void *)result;
13656   return jresult;
13657 }
13658
13659
13660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
13661   void * jresult ;
13662   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13663   Dali::Property::Array *arg2 = 0 ;
13664   Dali::Property::Array *result = 0 ;
13665
13666   arg1 = (Dali::Property::Array *)jarg1;
13667   arg2 = (Dali::Property::Array *)jarg2;
13668   if (!arg2) {
13669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13670     return 0;
13671   }
13672   {
13673     try {
13674       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
13675     } catch (std::out_of_range& e) {
13676       {
13677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13678       };
13679     } catch (std::exception& e) {
13680       {
13681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13682       };
13683     } catch (...) {
13684       {
13685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13686       };
13687     }
13688   }
13689   jresult = (void *)result;
13690   return jresult;
13691 }
13692
13693
13694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
13695   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13696   enum Dali::Property::Key::Type arg2 ;
13697
13698   arg1 = (Dali::Property::Key *)jarg1;
13699   arg2 = (enum Dali::Property::Key::Type)jarg2;
13700   if (arg1) (arg1)->type = arg2;
13701 }
13702
13703
13704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
13705   int jresult ;
13706   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13707   enum Dali::Property::Key::Type result;
13708
13709   arg1 = (Dali::Property::Key *)jarg1;
13710   result = (enum Dali::Property::Key::Type) ((arg1)->type);
13711   jresult = (int)result;
13712   return jresult;
13713 }
13714
13715
13716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
13717   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13718   Dali::Property::Index arg2 ;
13719
13720   arg1 = (Dali::Property::Key *)jarg1;
13721   arg2 = (Dali::Property::Index)jarg2;
13722   if (arg1) (arg1)->indexKey = arg2;
13723 }
13724
13725
13726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
13727   int jresult ;
13728   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13729   Dali::Property::Index result;
13730
13731   arg1 = (Dali::Property::Key *)jarg1;
13732   result = (Dali::Property::Index) ((arg1)->indexKey);
13733   jresult = result;
13734   return jresult;
13735 }
13736
13737
13738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
13739   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13740   std::string *arg2 = 0 ;
13741
13742   arg1 = (Dali::Property::Key *)jarg1;
13743   if (!jarg2) {
13744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13745     return ;
13746   }
13747   std::string arg2_str(jarg2);
13748   arg2 = &arg2_str;
13749   if (arg1) (arg1)->stringKey = *arg2;
13750
13751   //argout typemap for const std::string&
13752
13753 }
13754
13755
13756 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
13757   char * jresult ;
13758   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13759   std::string *result = 0 ;
13760
13761   arg1 = (Dali::Property::Key *)jarg1;
13762   result = (std::string *) & ((arg1)->stringKey);
13763   jresult = SWIG_csharp_string_callback(result->c_str());
13764   return jresult;
13765 }
13766
13767
13768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
13769   void * jresult ;
13770   std::string *arg1 = 0 ;
13771   Dali::Property::Key *result = 0 ;
13772
13773   if (!jarg1) {
13774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13775     return 0;
13776   }
13777   std::string arg1_str(jarg1);
13778   arg1 = &arg1_str;
13779   {
13780     try {
13781       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
13782     } catch (std::out_of_range& e) {
13783       {
13784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13785       };
13786     } catch (std::exception& e) {
13787       {
13788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13789       };
13790     } catch (...) {
13791       {
13792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13793       };
13794     }
13795   }
13796   jresult = (void *)result;
13797
13798   //argout typemap for const std::string&
13799
13800   return jresult;
13801 }
13802
13803
13804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
13805   void * jresult ;
13806   Dali::Property::Index arg1 ;
13807   Dali::Property::Key *result = 0 ;
13808
13809   arg1 = (Dali::Property::Index)jarg1;
13810   {
13811     try {
13812       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
13813     } catch (std::out_of_range& e) {
13814       {
13815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13816       };
13817     } catch (std::exception& e) {
13818       {
13819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13820       };
13821     } catch (...) {
13822       {
13823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13824       };
13825     }
13826   }
13827   jresult = (void *)result;
13828   return jresult;
13829 }
13830
13831
13832 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
13833   unsigned int jresult ;
13834   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13835   std::string *arg2 = 0 ;
13836   bool result;
13837
13838   arg1 = (Dali::Property::Key *)jarg1;
13839   if (!jarg2) {
13840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13841     return 0;
13842   }
13843   std::string arg2_str(jarg2);
13844   arg2 = &arg2_str;
13845   {
13846     try {
13847       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
13848     } catch (std::out_of_range& e) {
13849       {
13850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13851       };
13852     } catch (std::exception& e) {
13853       {
13854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13855       };
13856     } catch (...) {
13857       {
13858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13859       };
13860     }
13861   }
13862   jresult = result;
13863
13864   //argout typemap for const std::string&
13865
13866   return jresult;
13867 }
13868
13869
13870 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
13871   unsigned int jresult ;
13872   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13873   Dali::Property::Index arg2 ;
13874   bool result;
13875
13876   arg1 = (Dali::Property::Key *)jarg1;
13877   arg2 = (Dali::Property::Index)jarg2;
13878   {
13879     try {
13880       result = (bool)(arg1)->operator ==(arg2);
13881     } catch (std::out_of_range& e) {
13882       {
13883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13884       };
13885     } catch (std::exception& e) {
13886       {
13887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13888       };
13889     } catch (...) {
13890       {
13891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13892       };
13893     }
13894   }
13895   jresult = result;
13896   return jresult;
13897 }
13898
13899
13900 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
13901   unsigned int jresult ;
13902   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13903   Dali::Property::Key *arg2 = 0 ;
13904   bool result;
13905
13906   arg1 = (Dali::Property::Key *)jarg1;
13907   arg2 = (Dali::Property::Key *)jarg2;
13908   if (!arg2) {
13909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13910     return 0;
13911   }
13912   {
13913     try {
13914       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
13915     } catch (std::out_of_range& e) {
13916       {
13917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13918       };
13919     } catch (std::exception& e) {
13920       {
13921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13922       };
13923     } catch (...) {
13924       {
13925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13926       };
13927     }
13928   }
13929   jresult = result;
13930   return jresult;
13931 }
13932
13933
13934 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
13935   unsigned int jresult ;
13936   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13937   std::string *arg2 = 0 ;
13938   bool result;
13939
13940   arg1 = (Dali::Property::Key *)jarg1;
13941   if (!jarg2) {
13942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13943     return 0;
13944   }
13945   std::string arg2_str(jarg2);
13946   arg2 = &arg2_str;
13947   {
13948     try {
13949       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
13950     } catch (std::out_of_range& e) {
13951       {
13952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13953       };
13954     } catch (std::exception& e) {
13955       {
13956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13957       };
13958     } catch (...) {
13959       {
13960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13961       };
13962     }
13963   }
13964   jresult = result;
13965
13966   //argout typemap for const std::string&
13967
13968   return jresult;
13969 }
13970
13971
13972 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
13973   unsigned int jresult ;
13974   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13975   Dali::Property::Index arg2 ;
13976   bool result;
13977
13978   arg1 = (Dali::Property::Key *)jarg1;
13979   arg2 = (Dali::Property::Index)jarg2;
13980   {
13981     try {
13982       result = (bool)(arg1)->operator !=(arg2);
13983     } catch (std::out_of_range& e) {
13984       {
13985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13986       };
13987     } catch (std::exception& e) {
13988       {
13989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13990       };
13991     } catch (...) {
13992       {
13993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13994       };
13995     }
13996   }
13997   jresult = result;
13998   return jresult;
13999 }
14000
14001
14002 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
14003   unsigned int jresult ;
14004   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
14005   Dali::Property::Key *arg2 = 0 ;
14006   bool result;
14007
14008   arg1 = (Dali::Property::Key *)jarg1;
14009   arg2 = (Dali::Property::Key *)jarg2;
14010   if (!arg2) {
14011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
14012     return 0;
14013   }
14014   {
14015     try {
14016       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
14017     } catch (std::out_of_range& e) {
14018       {
14019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14020       };
14021     } catch (std::exception& e) {
14022       {
14023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14024       };
14025     } catch (...) {
14026       {
14027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14028       };
14029     }
14030   }
14031   jresult = result;
14032   return jresult;
14033 }
14034
14035
14036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
14037   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
14038
14039   arg1 = (Dali::Property::Key *)jarg1;
14040   {
14041     try {
14042       delete arg1;
14043     } catch (std::out_of_range& e) {
14044       {
14045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14046       };
14047     } catch (std::exception& e) {
14048       {
14049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14050       };
14051     } catch (...) {
14052       {
14053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14054       };
14055     }
14056   }
14057 }
14058
14059
14060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
14061   void * jresult ;
14062   Dali::Property::Map *result = 0 ;
14063
14064   {
14065     try {
14066       result = (Dali::Property::Map *)new Dali::Property::Map();
14067     } catch (std::out_of_range& e) {
14068       {
14069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14070       };
14071     } catch (std::exception& e) {
14072       {
14073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14074       };
14075     } catch (...) {
14076       {
14077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14078       };
14079     }
14080   }
14081   jresult = (void *)result;
14082   return jresult;
14083 }
14084
14085
14086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
14087   void * jresult ;
14088   Dali::Property::Map *arg1 = 0 ;
14089   Dali::Property::Map *result = 0 ;
14090
14091   arg1 = (Dali::Property::Map *)jarg1;
14092   if (!arg1) {
14093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14094     return 0;
14095   }
14096   {
14097     try {
14098       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
14099     } catch (std::out_of_range& e) {
14100       {
14101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14102       };
14103     } catch (std::exception& e) {
14104       {
14105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14106       };
14107     } catch (...) {
14108       {
14109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14110       };
14111     }
14112   }
14113   jresult = (void *)result;
14114   return jresult;
14115 }
14116
14117
14118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
14119   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14120
14121   arg1 = (Dali::Property::Map *)jarg1;
14122   {
14123     try {
14124       delete arg1;
14125     } catch (std::out_of_range& e) {
14126       {
14127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14128       };
14129     } catch (std::exception& e) {
14130       {
14131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14132       };
14133     } catch (...) {
14134       {
14135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14136       };
14137     }
14138   }
14139 }
14140
14141
14142 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
14143   unsigned long jresult ;
14144   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14145   Dali::Property::Map::SizeType result;
14146
14147   arg1 = (Dali::Property::Map *)jarg1;
14148   {
14149     try {
14150       result = ((Dali::Property::Map const *)arg1)->Count();
14151     } catch (std::out_of_range& e) {
14152       {
14153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14154       };
14155     } catch (std::exception& e) {
14156       {
14157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14158       };
14159     } catch (...) {
14160       {
14161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14162       };
14163     }
14164   }
14165   jresult = (unsigned long)result;
14166   return jresult;
14167 }
14168
14169
14170 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
14171   unsigned int jresult ;
14172   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14173   bool result;
14174
14175   arg1 = (Dali::Property::Map *)jarg1;
14176   {
14177     try {
14178       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
14179     } catch (std::out_of_range& e) {
14180       {
14181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14182       };
14183     } catch (std::exception& e) {
14184       {
14185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14186       };
14187     } catch (...) {
14188       {
14189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14190       };
14191     }
14192   }
14193   jresult = result;
14194   return jresult;
14195 }
14196
14197
14198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14199   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14200   char *arg2 = (char *) 0 ;
14201   Dali::Property::Value *arg3 = 0 ;
14202
14203   arg1 = (Dali::Property::Map *)jarg1;
14204   arg2 = (char *)jarg2;
14205   arg3 = (Dali::Property::Value *)jarg3;
14206   if (!arg3) {
14207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14208     return ;
14209   }
14210   {
14211     try {
14212       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
14213     } catch (std::out_of_range& e) {
14214       {
14215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14216       };
14217     } catch (std::exception& e) {
14218       {
14219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14220       };
14221     } catch (...) {
14222       {
14223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14224       };
14225     }
14226   }
14227 }
14228
14229
14230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14231   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14232   Dali::Property::Index arg2 ;
14233   Dali::Property::Value *arg3 = 0 ;
14234
14235   arg1 = (Dali::Property::Map *)jarg1;
14236   arg2 = (Dali::Property::Index)jarg2;
14237   arg3 = (Dali::Property::Value *)jarg3;
14238   if (!arg3) {
14239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14240     return ;
14241   }
14242   {
14243     try {
14244       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
14245     } catch (std::out_of_range& e) {
14246       {
14247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14248       };
14249     } catch (std::exception& e) {
14250       {
14251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14252       };
14253     } catch (...) {
14254       {
14255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14256       };
14257     }
14258   }
14259 }
14260
14261
14262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14263   void * jresult ;
14264   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14265   char *arg2 = (char *) 0 ;
14266   Dali::Property::Value *arg3 = 0 ;
14267   Dali::Property::Map *result = 0 ;
14268
14269   arg1 = (Dali::Property::Map *)jarg1;
14270   arg2 = (char *)jarg2;
14271   arg3 = (Dali::Property::Value *)jarg3;
14272   if (!arg3) {
14273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14274     return 0;
14275   }
14276   {
14277     try {
14278       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
14279     } catch (std::out_of_range& e) {
14280       {
14281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14282       };
14283     } catch (std::exception& e) {
14284       {
14285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14286       };
14287     } catch (...) {
14288       {
14289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14290       };
14291     }
14292   }
14293   jresult = (void *)result;
14294   return jresult;
14295 }
14296
14297
14298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14299   void * jresult ;
14300   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14301   Dali::Property::Index arg2 ;
14302   Dali::Property::Value *arg3 = 0 ;
14303   Dali::Property::Map *result = 0 ;
14304
14305   arg1 = (Dali::Property::Map *)jarg1;
14306   arg2 = (Dali::Property::Index)jarg2;
14307   arg3 = (Dali::Property::Value *)jarg3;
14308   if (!arg3) {
14309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14310     return 0;
14311   }
14312   {
14313     try {
14314       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
14315     } catch (std::out_of_range& e) {
14316       {
14317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14318       };
14319     } catch (std::exception& e) {
14320       {
14321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14322       };
14323     } catch (...) {
14324       {
14325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14326       };
14327     }
14328   }
14329   jresult = (void *)result;
14330   return jresult;
14331 }
14332
14333
14334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
14335   void * jresult ;
14336   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14337   Dali::Property::Map::SizeType arg2 ;
14338   Dali::Property::Value *result = 0 ;
14339
14340   arg1 = (Dali::Property::Map *)jarg1;
14341   arg2 = (Dali::Property::Map::SizeType)jarg2;
14342   {
14343     try {
14344       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
14345     } catch (std::out_of_range& e) {
14346       {
14347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14348       };
14349     } catch (std::exception& e) {
14350       {
14351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14352       };
14353     } catch (...) {
14354       {
14355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14356       };
14357     }
14358   }
14359   jresult = (void *)result;
14360   return jresult;
14361 }
14362
14363
14364 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
14365   char * jresult ;
14366   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14367   Dali::Property::Map::SizeType arg2 ;
14368   std::string *result = 0 ;
14369
14370   arg1 = (Dali::Property::Map *)jarg1;
14371   arg2 = (Dali::Property::Map::SizeType)jarg2;
14372   {
14373     try {
14374       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
14375     } catch (std::out_of_range& e) {
14376       {
14377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14378       };
14379     } catch (std::exception& e) {
14380       {
14381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14382       };
14383     } catch (...) {
14384       {
14385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14386       };
14387     }
14388   }
14389   jresult = SWIG_csharp_string_callback(result->c_str());
14390   return jresult;
14391 }
14392
14393
14394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
14395   void * jresult ;
14396   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14397   Dali::Property::Map::SizeType arg2 ;
14398   SwigValueWrapper< Dali::Property::Key > result;
14399
14400   arg1 = (Dali::Property::Map *)jarg1;
14401   arg2 = (Dali::Property::Map::SizeType)jarg2;
14402   {
14403     try {
14404       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
14405     } catch (std::out_of_range& e) {
14406       {
14407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14408       };
14409     } catch (std::exception& e) {
14410       {
14411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14412       };
14413     } catch (...) {
14414       {
14415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14416       };
14417     }
14418   }
14419   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
14420   return jresult;
14421 }
14422
14423
14424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
14425   void * jresult ;
14426   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14427   Dali::Property::Map::SizeType arg2 ;
14428   StringValuePair *result = 0 ;
14429
14430   arg1 = (Dali::Property::Map *)jarg1;
14431   arg2 = (Dali::Property::Map::SizeType)jarg2;
14432   {
14433     try {
14434       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
14435     } catch (std::out_of_range& e) {
14436       {
14437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14438       };
14439     } catch (std::exception& e) {
14440       {
14441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14442       };
14443     } catch (...) {
14444       {
14445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14446       };
14447     }
14448   }
14449   jresult = (void *)result;
14450   return jresult;
14451 }
14452
14453
14454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
14455   void * jresult ;
14456   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14457   char *arg2 = (char *) 0 ;
14458   Dali::Property::Value *result = 0 ;
14459
14460   arg1 = (Dali::Property::Map *)jarg1;
14461   arg2 = (char *)jarg2;
14462   {
14463     try {
14464       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
14465     } catch (std::out_of_range& e) {
14466       {
14467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14468       };
14469     } catch (std::exception& e) {
14470       {
14471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14472       };
14473     } catch (...) {
14474       {
14475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14476       };
14477     }
14478   }
14479   jresult = (void *)result;
14480   return jresult;
14481 }
14482
14483
14484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
14485   void * jresult ;
14486   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14487   Dali::Property::Index arg2 ;
14488   Dali::Property::Value *result = 0 ;
14489
14490   arg1 = (Dali::Property::Map *)jarg1;
14491   arg2 = (Dali::Property::Index)jarg2;
14492   {
14493     try {
14494       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
14495     } catch (std::out_of_range& e) {
14496       {
14497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14498       };
14499     } catch (std::exception& e) {
14500       {
14501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14502       };
14503     } catch (...) {
14504       {
14505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14506       };
14507     }
14508   }
14509   jresult = (void *)result;
14510   return jresult;
14511 }
14512
14513
14514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
14515   void * jresult ;
14516   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14517   Dali::Property::Index arg2 ;
14518   std::string *arg3 = 0 ;
14519   Dali::Property::Value *result = 0 ;
14520
14521   arg1 = (Dali::Property::Map *)jarg1;
14522   arg2 = (Dali::Property::Index)jarg2;
14523   if (!jarg3) {
14524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14525     return 0;
14526   }
14527   std::string arg3_str(jarg3);
14528   arg3 = &arg3_str;
14529   {
14530     try {
14531       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
14532     } catch (std::out_of_range& e) {
14533       {
14534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14535       };
14536     } catch (std::exception& e) {
14537       {
14538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14539       };
14540     } catch (...) {
14541       {
14542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14543       };
14544     }
14545   }
14546   jresult = (void *)result;
14547
14548   //argout typemap for const std::string&
14549
14550   return jresult;
14551 }
14552
14553
14554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
14555   void * jresult ;
14556   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14557   std::string *arg2 = 0 ;
14558   Dali::Property::Type arg3 ;
14559   Dali::Property::Value *result = 0 ;
14560
14561   arg1 = (Dali::Property::Map *)jarg1;
14562   if (!jarg2) {
14563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14564     return 0;
14565   }
14566   std::string arg2_str(jarg2);
14567   arg2 = &arg2_str;
14568   arg3 = (Dali::Property::Type)jarg3;
14569   {
14570     try {
14571       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
14572     } catch (std::out_of_range& e) {
14573       {
14574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14575       };
14576     } catch (std::exception& e) {
14577       {
14578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14579       };
14580     } catch (...) {
14581       {
14582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14583       };
14584     }
14585   }
14586   jresult = (void *)result;
14587
14588   //argout typemap for const std::string&
14589
14590   return jresult;
14591 }
14592
14593
14594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
14595   void * jresult ;
14596   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14597   Dali::Property::Index arg2 ;
14598   Dali::Property::Type arg3 ;
14599   Dali::Property::Value *result = 0 ;
14600
14601   arg1 = (Dali::Property::Map *)jarg1;
14602   arg2 = (Dali::Property::Index)jarg2;
14603   arg3 = (Dali::Property::Type)jarg3;
14604   {
14605     try {
14606       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
14607     } catch (std::out_of_range& e) {
14608       {
14609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14610       };
14611     } catch (std::exception& e) {
14612       {
14613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14614       };
14615     } catch (...) {
14616       {
14617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14618       };
14619     }
14620   }
14621   jresult = (void *)result;
14622   return jresult;
14623 }
14624
14625
14626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
14627   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14628
14629   arg1 = (Dali::Property::Map *)jarg1;
14630   {
14631     try {
14632       (arg1)->Clear();
14633     } catch (std::out_of_range& e) {
14634       {
14635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14636       };
14637     } catch (std::exception& e) {
14638       {
14639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14640       };
14641     } catch (...) {
14642       {
14643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14644       };
14645     }
14646   }
14647 }
14648
14649
14650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
14651   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14652   Dali::Property::Map *arg2 = 0 ;
14653
14654   arg1 = (Dali::Property::Map *)jarg1;
14655   arg2 = (Dali::Property::Map *)jarg2;
14656   if (!arg2) {
14657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14658     return ;
14659   }
14660   {
14661     try {
14662       (arg1)->Merge((Dali::Property::Map const &)*arg2);
14663     } catch (std::out_of_range& e) {
14664       {
14665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14666       };
14667     } catch (std::exception& e) {
14668       {
14669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14670       };
14671     } catch (...) {
14672       {
14673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14674       };
14675     }
14676   }
14677 }
14678
14679
14680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
14681   void * jresult ;
14682   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14683   std::string *arg2 = 0 ;
14684   Dali::Property::Value *result = 0 ;
14685
14686   arg1 = (Dali::Property::Map *)jarg1;
14687   if (!jarg2) {
14688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14689     return 0;
14690   }
14691   std::string arg2_str(jarg2);
14692   arg2 = &arg2_str;
14693   {
14694     try {
14695       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
14696     } catch (std::out_of_range& e) {
14697       {
14698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14699       };
14700     } catch (std::exception& e) {
14701       {
14702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14703       };
14704     } catch (...) {
14705       {
14706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14707       };
14708     }
14709   }
14710   jresult = (void *)result;
14711
14712   //argout typemap for const std::string&
14713
14714   return jresult;
14715 }
14716
14717
14718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
14719   void * jresult ;
14720   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14721   Dali::Property::Index arg2 ;
14722   Dali::Property::Value *result = 0 ;
14723
14724   arg1 = (Dali::Property::Map *)jarg1;
14725   arg2 = (Dali::Property::Index)jarg2;
14726   {
14727     try {
14728       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
14729     } catch (std::out_of_range& e) {
14730       {
14731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14732       };
14733     } catch (std::exception& e) {
14734       {
14735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14736       };
14737     } catch (...) {
14738       {
14739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14740       };
14741     }
14742   }
14743   jresult = (void *)result;
14744   return jresult;
14745 }
14746
14747
14748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
14749   void * jresult ;
14750   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14751   Dali::Property::Map *arg2 = 0 ;
14752   Dali::Property::Map *result = 0 ;
14753
14754   arg1 = (Dali::Property::Map *)jarg1;
14755   arg2 = (Dali::Property::Map *)jarg2;
14756   if (!arg2) {
14757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14758     return 0;
14759   }
14760   {
14761     try {
14762       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
14763     } catch (std::out_of_range& e) {
14764       {
14765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14766       };
14767     } catch (std::exception& e) {
14768       {
14769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14770       };
14771     } catch (...) {
14772       {
14773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14774       };
14775     }
14776   }
14777   jresult = (void *)result;
14778   return jresult;
14779 }
14780
14781
14782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
14783   void * jresult ;
14784   Dali::Property::Value *result = 0 ;
14785
14786   {
14787     try {
14788       result = (Dali::Property::Value *)new Dali::Property::Value();
14789     } catch (std::out_of_range& e) {
14790       {
14791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14792       };
14793     } catch (std::exception& e) {
14794       {
14795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14796       };
14797     } catch (...) {
14798       {
14799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14800       };
14801     }
14802   }
14803   jresult = (void *)result;
14804   return jresult;
14805 }
14806
14807
14808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
14809   void * jresult ;
14810   bool arg1 ;
14811   Dali::Property::Value *result = 0 ;
14812
14813   arg1 = jarg1 ? true : false;
14814   {
14815     try {
14816       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14817     } catch (std::out_of_range& e) {
14818       {
14819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14820       };
14821     } catch (std::exception& e) {
14822       {
14823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14824       };
14825     } catch (...) {
14826       {
14827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14828       };
14829     }
14830   }
14831   jresult = (void *)result;
14832   return jresult;
14833 }
14834
14835
14836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
14837   void * jresult ;
14838   int arg1 ;
14839   Dali::Property::Value *result = 0 ;
14840
14841   arg1 = (int)jarg1;
14842   {
14843     try {
14844       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14845     } catch (std::out_of_range& e) {
14846       {
14847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14848       };
14849     } catch (std::exception& e) {
14850       {
14851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14852       };
14853     } catch (...) {
14854       {
14855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14856       };
14857     }
14858   }
14859   jresult = (void *)result;
14860   return jresult;
14861 }
14862
14863
14864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
14865   void * jresult ;
14866   float arg1 ;
14867   Dali::Property::Value *result = 0 ;
14868
14869   arg1 = (float)jarg1;
14870   {
14871     try {
14872       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14873     } catch (std::out_of_range& e) {
14874       {
14875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14876       };
14877     } catch (std::exception& e) {
14878       {
14879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14880       };
14881     } catch (...) {
14882       {
14883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14884       };
14885     }
14886   }
14887   jresult = (void *)result;
14888   return jresult;
14889 }
14890
14891
14892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
14893   void * jresult ;
14894   Dali::Vector2 *arg1 = 0 ;
14895   Dali::Property::Value *result = 0 ;
14896
14897   arg1 = (Dali::Vector2 *)jarg1;
14898   if (!arg1) {
14899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
14900     return 0;
14901   }
14902   {
14903     try {
14904       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
14905     } catch (std::out_of_range& e) {
14906       {
14907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14908       };
14909     } catch (std::exception& e) {
14910       {
14911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14912       };
14913     } catch (...) {
14914       {
14915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14916       };
14917     }
14918   }
14919   jresult = (void *)result;
14920   return jresult;
14921 }
14922
14923
14924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
14925   void * jresult ;
14926   Dali::Vector3 *arg1 = 0 ;
14927   Dali::Property::Value *result = 0 ;
14928
14929   arg1 = (Dali::Vector3 *)jarg1;
14930   if (!arg1) {
14931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14932     return 0;
14933   }
14934   {
14935     try {
14936       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
14937     } catch (std::out_of_range& e) {
14938       {
14939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14940       };
14941     } catch (std::exception& e) {
14942       {
14943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14944       };
14945     } catch (...) {
14946       {
14947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14948       };
14949     }
14950   }
14951   jresult = (void *)result;
14952   return jresult;
14953 }
14954
14955
14956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
14957   void * jresult ;
14958   Dali::Vector4 *arg1 = 0 ;
14959   Dali::Property::Value *result = 0 ;
14960
14961   arg1 = (Dali::Vector4 *)jarg1;
14962   if (!arg1) {
14963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
14964     return 0;
14965   }
14966   {
14967     try {
14968       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
14969     } catch (std::out_of_range& e) {
14970       {
14971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14972       };
14973     } catch (std::exception& e) {
14974       {
14975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14976       };
14977     } catch (...) {
14978       {
14979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14980       };
14981     }
14982   }
14983   jresult = (void *)result;
14984   return jresult;
14985 }
14986
14987
14988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
14989   void * jresult ;
14990   Dali::Matrix3 *arg1 = 0 ;
14991   Dali::Property::Value *result = 0 ;
14992
14993   arg1 = (Dali::Matrix3 *)jarg1;
14994   if (!arg1) {
14995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
14996     return 0;
14997   }
14998   {
14999     try {
15000       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
15001     } catch (std::out_of_range& e) {
15002       {
15003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15004       };
15005     } catch (std::exception& e) {
15006       {
15007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15008       };
15009     } catch (...) {
15010       {
15011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15012       };
15013     }
15014   }
15015   jresult = (void *)result;
15016   return jresult;
15017 }
15018
15019
15020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
15021   void * jresult ;
15022   Dali::Matrix *arg1 = 0 ;
15023   Dali::Property::Value *result = 0 ;
15024
15025   arg1 = (Dali::Matrix *)jarg1;
15026   if (!arg1) {
15027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
15028     return 0;
15029   }
15030   {
15031     try {
15032       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
15033     } catch (std::out_of_range& e) {
15034       {
15035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15036       };
15037     } catch (std::exception& e) {
15038       {
15039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15040       };
15041     } catch (...) {
15042       {
15043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15044       };
15045     }
15046   }
15047   jresult = (void *)result;
15048   return jresult;
15049 }
15050
15051
15052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
15053   void * jresult ;
15054   Dali::Rect< int > *arg1 = 0 ;
15055   Dali::Property::Value *result = 0 ;
15056
15057   arg1 = (Dali::Rect< int > *)jarg1;
15058   if (!arg1) {
15059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
15060     return 0;
15061   }
15062   {
15063     try {
15064       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
15065     } catch (std::out_of_range& e) {
15066       {
15067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15068       };
15069     } catch (std::exception& e) {
15070       {
15071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15072       };
15073     } catch (...) {
15074       {
15075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15076       };
15077     }
15078   }
15079   jresult = (void *)result;
15080   return jresult;
15081 }
15082
15083
15084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
15085   void * jresult ;
15086   Dali::AngleAxis *arg1 = 0 ;
15087   Dali::Property::Value *result = 0 ;
15088
15089   arg1 = (Dali::AngleAxis *)jarg1;
15090   if (!arg1) {
15091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
15092     return 0;
15093   }
15094   {
15095     try {
15096       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
15097     } catch (std::out_of_range& e) {
15098       {
15099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15100       };
15101     } catch (std::exception& e) {
15102       {
15103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15104       };
15105     } catch (...) {
15106       {
15107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15108       };
15109     }
15110   }
15111   jresult = (void *)result;
15112   return jresult;
15113 }
15114
15115
15116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
15117   void * jresult ;
15118   Dali::Quaternion *arg1 = 0 ;
15119   Dali::Property::Value *result = 0 ;
15120
15121   arg1 = (Dali::Quaternion *)jarg1;
15122   if (!arg1) {
15123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
15124     return 0;
15125   }
15126   {
15127     try {
15128       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
15129     } catch (std::out_of_range& e) {
15130       {
15131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15132       };
15133     } catch (std::exception& e) {
15134       {
15135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15136       };
15137     } catch (...) {
15138       {
15139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15140       };
15141     }
15142   }
15143   jresult = (void *)result;
15144   return jresult;
15145 }
15146
15147
15148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
15149   void * jresult ;
15150   std::string *arg1 = 0 ;
15151   Dali::Property::Value *result = 0 ;
15152
15153   if (!jarg1) {
15154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15155     return 0;
15156   }
15157   std::string arg1_str(jarg1);
15158   arg1 = &arg1_str;
15159   {
15160     try {
15161       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
15162     } catch (std::out_of_range& e) {
15163       {
15164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15165       };
15166     } catch (std::exception& e) {
15167       {
15168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15169       };
15170     } catch (...) {
15171       {
15172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15173       };
15174     }
15175   }
15176   jresult = (void *)result;
15177
15178   //argout typemap for const std::string&
15179
15180   return jresult;
15181 }
15182
15183
15184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
15185   void * jresult ;
15186   Dali::Property::Array *arg1 = 0 ;
15187   Dali::Property::Value *result = 0 ;
15188
15189   arg1 = (Dali::Property::Array *)jarg1;
15190   if (!arg1) {
15191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15192     return 0;
15193   }
15194   {
15195     try {
15196       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15197     } catch (std::out_of_range& e) {
15198       {
15199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15200       };
15201     } catch (std::exception& e) {
15202       {
15203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15204       };
15205     } catch (...) {
15206       {
15207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15208       };
15209     }
15210   }
15211   jresult = (void *)result;
15212   return jresult;
15213 }
15214
15215
15216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
15217   void * jresult ;
15218   Dali::Property::Map *arg1 = 0 ;
15219   Dali::Property::Value *result = 0 ;
15220
15221   arg1 = (Dali::Property::Map *)jarg1;
15222   if (!arg1) {
15223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15224     return 0;
15225   }
15226   {
15227     try {
15228       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15229     } catch (std::out_of_range& e) {
15230       {
15231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15232       };
15233     } catch (std::exception& e) {
15234       {
15235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15236       };
15237     } catch (...) {
15238       {
15239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15240       };
15241     }
15242   }
15243   jresult = (void *)result;
15244   return jresult;
15245 }
15246
15247
15248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(int jarg1) {
15249   void * jresult ;
15250   Dali::Property::Type arg1 ;
15251   Dali::Property::Value *result = 0 ;
15252
15253   arg1 = (Dali::Property::Type)jarg1;
15254   {
15255     try {
15256       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
15257     } catch (std::out_of_range& e) {
15258       {
15259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15260       };
15261     } catch (std::exception& e) {
15262       {
15263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15264       };
15265     } catch (...) {
15266       {
15267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15268       };
15269     }
15270   }
15271   jresult = (void *)result;
15272   return jresult;
15273 }
15274
15275
15276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(void * jarg1) {
15277   void * jresult ;
15278   Dali::Property::Value *arg1 = 0 ;
15279   Dali::Property::Value *result = 0 ;
15280
15281   arg1 = (Dali::Property::Value *)jarg1;
15282   if (!arg1) {
15283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15284     return 0;
15285   }
15286   {
15287     try {
15288       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
15289     } catch (std::out_of_range& e) {
15290       {
15291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15292       };
15293     } catch (std::exception& e) {
15294       {
15295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15296       };
15297     } catch (...) {
15298       {
15299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15300       };
15301     }
15302   }
15303   jresult = (void *)result;
15304   return jresult;
15305 }
15306
15307
15308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
15309   void * jresult ;
15310   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15311   Dali::Property::Value *arg2 = 0 ;
15312   Dali::Property::Value *result = 0 ;
15313
15314   arg1 = (Dali::Property::Value *)jarg1;
15315   arg2 = (Dali::Property::Value *)jarg2;
15316   if (!arg2) {
15317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15318     return 0;
15319   }
15320   {
15321     try {
15322       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
15323     } catch (std::out_of_range& e) {
15324       {
15325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15326       };
15327     } catch (std::exception& e) {
15328       {
15329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15330       };
15331     } catch (...) {
15332       {
15333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15334       };
15335     }
15336   }
15337   jresult = (void *)result;
15338   return jresult;
15339 }
15340
15341
15342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
15343   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15344
15345   arg1 = (Dali::Property::Value *)jarg1;
15346   {
15347     try {
15348       delete arg1;
15349     } catch (std::out_of_range& e) {
15350       {
15351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15352       };
15353     } catch (std::exception& e) {
15354       {
15355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15356       };
15357     } catch (...) {
15358       {
15359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15360       };
15361     }
15362   }
15363 }
15364
15365
15366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
15367   int jresult ;
15368   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15369   Dali::Property::Type result;
15370
15371   arg1 = (Dali::Property::Value *)jarg1;
15372   {
15373     try {
15374       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
15375     } catch (std::out_of_range& e) {
15376       {
15377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15378       };
15379     } catch (std::exception& e) {
15380       {
15381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15382       };
15383     } catch (...) {
15384       {
15385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15386       };
15387     }
15388   }
15389   jresult = (int)result;
15390   return jresult;
15391 }
15392
15393
15394 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
15395   unsigned int jresult ;
15396   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15397   bool *arg2 = 0 ;
15398   bool result;
15399
15400   arg1 = (Dali::Property::Value *)jarg1;
15401   arg2 = (bool *)jarg2;
15402   {
15403     try {
15404       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15405     } catch (std::out_of_range& e) {
15406       {
15407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15408       };
15409     } catch (std::exception& e) {
15410       {
15411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15412       };
15413     } catch (...) {
15414       {
15415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15416       };
15417     }
15418   }
15419   jresult = result;
15420   return jresult;
15421 }
15422
15423
15424 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
15425   unsigned int jresult ;
15426   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15427   float *arg2 = 0 ;
15428   bool result;
15429
15430   arg1 = (Dali::Property::Value *)jarg1;
15431   arg2 = (float *)jarg2;
15432   {
15433     try {
15434       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15435     } catch (std::out_of_range& e) {
15436       {
15437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15438       };
15439     } catch (std::exception& e) {
15440       {
15441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15442       };
15443     } catch (...) {
15444       {
15445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15446       };
15447     }
15448   }
15449   jresult = result;
15450   return jresult;
15451 }
15452
15453
15454 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
15455   unsigned int jresult ;
15456   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15457   int *arg2 = 0 ;
15458   bool result;
15459
15460   arg1 = (Dali::Property::Value *)jarg1;
15461   arg2 = (int *)jarg2;
15462   {
15463     try {
15464       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15465     } catch (std::out_of_range& e) {
15466       {
15467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15468       };
15469     } catch (std::exception& e) {
15470       {
15471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15472       };
15473     } catch (...) {
15474       {
15475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15476       };
15477     }
15478   }
15479   jresult = result;
15480   return jresult;
15481 }
15482
15483
15484 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
15485   unsigned int jresult ;
15486   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15487   Dali::Rect< int > *arg2 = 0 ;
15488   bool result;
15489
15490   arg1 = (Dali::Property::Value *)jarg1;
15491   arg2 = (Dali::Rect< int > *)jarg2;
15492   if (!arg2) {
15493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
15494     return 0;
15495   }
15496   {
15497     try {
15498       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15499     } catch (std::out_of_range& e) {
15500       {
15501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15502       };
15503     } catch (std::exception& e) {
15504       {
15505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15506       };
15507     } catch (...) {
15508       {
15509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15510       };
15511     }
15512   }
15513   jresult = result;
15514   return jresult;
15515 }
15516
15517
15518 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
15519   unsigned int jresult ;
15520   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15521   Dali::Vector2 *arg2 = 0 ;
15522   bool result;
15523
15524   arg1 = (Dali::Property::Value *)jarg1;
15525   arg2 = (Dali::Vector2 *)jarg2;
15526   if (!arg2) {
15527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
15528     return 0;
15529   }
15530   {
15531     try {
15532       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15533     } catch (std::out_of_range& e) {
15534       {
15535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15536       };
15537     } catch (std::exception& e) {
15538       {
15539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15540       };
15541     } catch (...) {
15542       {
15543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15544       };
15545     }
15546   }
15547   jresult = result;
15548   return jresult;
15549 }
15550
15551
15552 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
15553   unsigned int jresult ;
15554   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15555   Dali::Vector3 *arg2 = 0 ;
15556   bool result;
15557
15558   arg1 = (Dali::Property::Value *)jarg1;
15559   arg2 = (Dali::Vector3 *)jarg2;
15560   if (!arg2) {
15561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
15562     return 0;
15563   }
15564   {
15565     try {
15566       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15567     } catch (std::out_of_range& e) {
15568       {
15569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15570       };
15571     } catch (std::exception& e) {
15572       {
15573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15574       };
15575     } catch (...) {
15576       {
15577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15578       };
15579     }
15580   }
15581   jresult = result;
15582   return jresult;
15583 }
15584
15585
15586 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
15587   unsigned int jresult ;
15588   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15589   Dali::Vector4 *arg2 = 0 ;
15590   bool result;
15591
15592   arg1 = (Dali::Property::Value *)jarg1;
15593   arg2 = (Dali::Vector4 *)jarg2;
15594   if (!arg2) {
15595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
15596     return 0;
15597   }
15598   {
15599     try {
15600       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15601     } catch (std::out_of_range& e) {
15602       {
15603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15604       };
15605     } catch (std::exception& e) {
15606       {
15607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15608       };
15609     } catch (...) {
15610       {
15611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15612       };
15613     }
15614   }
15615   jresult = result;
15616   return jresult;
15617 }
15618
15619
15620 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
15621   unsigned int jresult ;
15622   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15623   Dali::Matrix3 *arg2 = 0 ;
15624   bool result;
15625
15626   arg1 = (Dali::Property::Value *)jarg1;
15627   arg2 = (Dali::Matrix3 *)jarg2;
15628   if (!arg2) {
15629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
15630     return 0;
15631   }
15632   {
15633     try {
15634       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15635     } catch (std::out_of_range& e) {
15636       {
15637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15638       };
15639     } catch (std::exception& e) {
15640       {
15641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15642       };
15643     } catch (...) {
15644       {
15645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15646       };
15647     }
15648   }
15649   jresult = result;
15650   return jresult;
15651 }
15652
15653
15654 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
15655   unsigned int jresult ;
15656   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15657   Dali::Matrix *arg2 = 0 ;
15658   bool result;
15659
15660   arg1 = (Dali::Property::Value *)jarg1;
15661   arg2 = (Dali::Matrix *)jarg2;
15662   if (!arg2) {
15663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
15664     return 0;
15665   }
15666   {
15667     try {
15668       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15669     } catch (std::out_of_range& e) {
15670       {
15671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15672       };
15673     } catch (std::exception& e) {
15674       {
15675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15676       };
15677     } catch (...) {
15678       {
15679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15680       };
15681     }
15682   }
15683   jresult = result;
15684   return jresult;
15685 }
15686
15687
15688 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
15689   unsigned int jresult ;
15690   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15691   Dali::AngleAxis *arg2 = 0 ;
15692   bool result;
15693
15694   arg1 = (Dali::Property::Value *)jarg1;
15695   arg2 = (Dali::AngleAxis *)jarg2;
15696   if (!arg2) {
15697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
15698     return 0;
15699   }
15700   {
15701     try {
15702       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15703     } catch (std::out_of_range& e) {
15704       {
15705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15706       };
15707     } catch (std::exception& e) {
15708       {
15709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15710       };
15711     } catch (...) {
15712       {
15713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15714       };
15715     }
15716   }
15717   jresult = result;
15718   return jresult;
15719 }
15720
15721
15722 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
15723   unsigned int jresult ;
15724   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15725   Dali::Quaternion *arg2 = 0 ;
15726   bool result;
15727
15728   arg1 = (Dali::Property::Value *)jarg1;
15729   arg2 = (Dali::Quaternion *)jarg2;
15730   if (!arg2) {
15731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
15732     return 0;
15733   }
15734   {
15735     try {
15736       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15737     } catch (std::out_of_range& e) {
15738       {
15739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15740       };
15741     } catch (std::exception& e) {
15742       {
15743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15744       };
15745     } catch (...) {
15746       {
15747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15748       };
15749     }
15750   }
15751   jresult = result;
15752   return jresult;
15753 }
15754
15755
15756 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
15757   unsigned int jresult ;
15758   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15759   std::string *arg2 = 0 ;
15760   bool result;
15761
15762   arg1 = (Dali::Property::Value *)jarg1;
15763
15764   //typemap in
15765   std::string temp;
15766   arg2 = &temp;
15767
15768   {
15769     try {
15770       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15771     } catch (std::out_of_range& e) {
15772       {
15773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15774       };
15775     } catch (std::exception& e) {
15776       {
15777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15778       };
15779     } catch (...) {
15780       {
15781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15782       };
15783     }
15784   }
15785   jresult = result;
15786
15787   //Typemap argout in c++ file.
15788   //This will convert c++ string to c# string
15789   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
15790
15791   return jresult;
15792 }
15793
15794
15795 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
15796   unsigned int jresult ;
15797   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15798   Dali::Property::Array *arg2 = 0 ;
15799   bool result;
15800
15801   arg1 = (Dali::Property::Value *)jarg1;
15802   arg2 = (Dali::Property::Array *)jarg2;
15803   if (!arg2) {
15804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15805     return 0;
15806   }
15807   {
15808     try {
15809       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15810     } catch (std::out_of_range& e) {
15811       {
15812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15813       };
15814     } catch (std::exception& e) {
15815       {
15816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15817       };
15818     } catch (...) {
15819       {
15820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15821       };
15822     }
15823   }
15824   jresult = result;
15825   return jresult;
15826 }
15827
15828
15829 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
15830   unsigned int jresult ;
15831   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15832   Dali::Property::Map *arg2 = 0 ;
15833   bool result;
15834
15835   arg1 = (Dali::Property::Value *)jarg1;
15836   arg2 = (Dali::Property::Map *)jarg2;
15837   if (!arg2) {
15838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15839     return 0;
15840   }
15841   {
15842     try {
15843       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15844     } catch (std::out_of_range& e) {
15845       {
15846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15847       };
15848     } catch (std::exception& e) {
15849       {
15850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15851       };
15852     } catch (...) {
15853       {
15854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15855       };
15856     }
15857   }
15858   jresult = result;
15859   return jresult;
15860 }
15861
15862
15863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
15864   void * jresult ;
15865   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15866   Dali::Property::Array *result = 0 ;
15867
15868   arg1 = (Dali::Property::Value *)jarg1;
15869   {
15870     try {
15871       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
15872     } catch (std::out_of_range& e) {
15873       {
15874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15875       };
15876     } catch (std::exception& e) {
15877       {
15878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15879       };
15880     } catch (...) {
15881       {
15882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15883       };
15884     }
15885   }
15886   jresult = (void *)result;
15887   return jresult;
15888 }
15889
15890
15891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
15892   void * jresult ;
15893   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15894   Dali::Property::Map *result = 0 ;
15895
15896   arg1 = (Dali::Property::Value *)jarg1;
15897   {
15898     try {
15899       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
15900     } catch (std::out_of_range& e) {
15901       {
15902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15903       };
15904     } catch (std::exception& e) {
15905       {
15906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15907       };
15908     } catch (...) {
15909       {
15910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15911       };
15912     }
15913   }
15914   jresult = (void *)result;
15915   return jresult;
15916 }
15917
15918
15919 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
15920   char * jresult ;
15921   Dali::Property::Type arg1 ;
15922   char *result = 0 ;
15923
15924   arg1 = (Dali::Property::Type)jarg1;
15925   {
15926     try {
15927       result = (char *)Dali::PropertyTypes::GetName(arg1);
15928     } catch (std::out_of_range& e) {
15929       {
15930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15931       };
15932     } catch (std::exception& e) {
15933       {
15934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15935       };
15936     } catch (...) {
15937       {
15938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15939       };
15940     }
15941   }
15942   jresult = SWIG_csharp_string_callback((const char *)result);
15943   return jresult;
15944 }
15945
15946
15947 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
15948   unsigned int jresult ;
15949   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15950   std::string *arg2 = 0 ;
15951   Dali::Property::Map *arg3 = 0 ;
15952   bool result;
15953
15954   arg1 = (Dali::BaseObject *)jarg1;
15955   if (!jarg2) {
15956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15957     return 0;
15958   }
15959   std::string arg2_str(jarg2);
15960   arg2 = &arg2_str;
15961   arg3 = (Dali::Property::Map *)jarg3;
15962   if (!arg3) {
15963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15964     return 0;
15965   }
15966   {
15967     try {
15968       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
15969     } catch (std::out_of_range& e) {
15970       {
15971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15972       };
15973     } catch (std::exception& e) {
15974       {
15975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15976       };
15977     } catch (...) {
15978       {
15979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15980       };
15981     }
15982   }
15983   jresult = result;
15984
15985   //argout typemap for const std::string&
15986
15987   return jresult;
15988 }
15989
15990
15991 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
15992   char * jresult ;
15993   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15994   std::string *result = 0 ;
15995
15996   arg1 = (Dali::BaseObject *)jarg1;
15997   {
15998     try {
15999       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
16000     } catch (std::out_of_range& e) {
16001       {
16002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16003       };
16004     } catch (std::exception& e) {
16005       {
16006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16007       };
16008     } catch (...) {
16009       {
16010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16011       };
16012     }
16013   }
16014   jresult = SWIG_csharp_string_callback(result->c_str());
16015   return jresult;
16016 }
16017
16018
16019 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
16020   unsigned int jresult ;
16021   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16022   Dali::TypeInfo *arg2 = 0 ;
16023   bool result;
16024
16025   arg1 = (Dali::BaseObject *)jarg1;
16026   arg2 = (Dali::TypeInfo *)jarg2;
16027   if (!arg2) {
16028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
16029     return 0;
16030   }
16031   {
16032     try {
16033       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
16034     } catch (std::out_of_range& e) {
16035       {
16036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16037       };
16038     } catch (std::exception& e) {
16039       {
16040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16041       };
16042     } catch (...) {
16043       {
16044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16045       };
16046     }
16047   }
16048   jresult = result;
16049   return jresult;
16050 }
16051
16052
16053 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
16054   unsigned int jresult ;
16055   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16056   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
16057   std::string *arg3 = 0 ;
16058   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
16059   bool result;
16060
16061   arg1 = (Dali::BaseObject *)jarg1;
16062   arg2 = (ConnectionTrackerInterface *)jarg2;
16063   if (!jarg3) {
16064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16065     return 0;
16066   }
16067   std::string arg3_str(jarg3);
16068   arg3 = &arg3_str;
16069   arg4 = (FunctorDelegate *)jarg4;
16070   {
16071     try {
16072       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
16073     } catch (std::out_of_range& e) {
16074       {
16075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16076       };
16077     } catch (std::exception& e) {
16078       {
16079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16080       };
16081     } catch (...) {
16082       {
16083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16084       };
16085     }
16086   }
16087   jresult = result;
16088
16089   //argout typemap for const std::string&
16090
16091   return jresult;
16092 }
16093
16094
16095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
16096   void * jresult ;
16097   Dali::BaseHandle *arg1 = 0 ;
16098   Dali::BaseObject *result = 0 ;
16099
16100   arg1 = (Dali::BaseHandle *)jarg1;
16101   if (!arg1) {
16102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16103     return 0;
16104   }
16105   {
16106     try {
16107       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
16108     } catch (std::out_of_range& e) {
16109       {
16110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16111       };
16112     } catch (std::exception& e) {
16113       {
16114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16115       };
16116     } catch (...) {
16117       {
16118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16119       };
16120     }
16121   }
16122   jresult = (void *)result;
16123   return jresult;
16124 }
16125
16126
16127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
16128   void * jresult ;
16129   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16130   Dali::BaseHandle *result = 0 ;
16131
16132   arg1 = (Dali::BaseObject *)jarg1;
16133   {
16134     try {
16135       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
16136     } catch (std::out_of_range& e) {
16137       {
16138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16139       };
16140     } catch (std::exception& e) {
16141       {
16142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16143       };
16144     } catch (...) {
16145       {
16146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16147       };
16148     }
16149   }
16150   jresult = (void *)result;
16151   return jresult;
16152 }
16153
16154
16155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
16156   void * jresult ;
16157   Dali::BaseHandle *result = 0 ;
16158
16159   {
16160     try {
16161       result = (Dali::BaseHandle *)new Dali::BaseHandle();
16162     } catch (std::out_of_range& e) {
16163       {
16164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16165       };
16166     } catch (std::exception& e) {
16167       {
16168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16169       };
16170     } catch (...) {
16171       {
16172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16173       };
16174     }
16175   }
16176   jresult = (void *)result;
16177   return jresult;
16178 }
16179
16180
16181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
16182   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16183
16184   arg1 = (Dali::BaseHandle *)jarg1;
16185   {
16186     try {
16187       delete arg1;
16188     } catch (std::out_of_range& e) {
16189       {
16190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16191       };
16192     } catch (std::exception& e) {
16193       {
16194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16195       };
16196     } catch (...) {
16197       {
16198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16199       };
16200     }
16201   }
16202 }
16203
16204
16205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
16206   void * jresult ;
16207   Dali::BaseHandle *arg1 = 0 ;
16208   Dali::BaseHandle *result = 0 ;
16209
16210   arg1 = (Dali::BaseHandle *)jarg1;
16211   if (!arg1) {
16212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16213     return 0;
16214   }
16215   {
16216     try {
16217       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
16218     } catch (std::out_of_range& e) {
16219       {
16220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16221       };
16222     } catch (std::exception& e) {
16223       {
16224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16225       };
16226     } catch (...) {
16227       {
16228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16229       };
16230     }
16231   }
16232   jresult = (void *)result;
16233   return jresult;
16234 }
16235
16236
16237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
16238   void * jresult ;
16239   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16240   Dali::BaseHandle *arg2 = 0 ;
16241   Dali::BaseHandle *result = 0 ;
16242
16243   arg1 = (Dali::BaseHandle *)jarg1;
16244   arg2 = (Dali::BaseHandle *)jarg2;
16245   if (!arg2) {
16246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16247     return 0;
16248   }
16249   {
16250     try {
16251       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
16252     } catch (std::out_of_range& e) {
16253       {
16254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16255       };
16256     } catch (std::exception& e) {
16257       {
16258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16259       };
16260     } catch (...) {
16261       {
16262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16263       };
16264     }
16265   }
16266   jresult = (void *)result;
16267   return jresult;
16268 }
16269
16270
16271 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
16272   unsigned int jresult ;
16273   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16274   std::string *arg2 = 0 ;
16275   Dali::Property::Map *arg3 = 0 ;
16276   bool result;
16277
16278   arg1 = (Dali::BaseHandle *)jarg1;
16279   if (!jarg2) {
16280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16281     return 0;
16282   }
16283   std::string arg2_str(jarg2);
16284   arg2 = &arg2_str;
16285   arg3 = (Dali::Property::Map *)jarg3;
16286   if (!arg3) {
16287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16288     return 0;
16289   }
16290   {
16291     try {
16292       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
16293     } catch (std::out_of_range& e) {
16294       {
16295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16296       };
16297     } catch (std::exception& e) {
16298       {
16299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16300       };
16301     } catch (...) {
16302       {
16303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16304       };
16305     }
16306   }
16307   jresult = result;
16308
16309   //argout typemap for const std::string&
16310
16311   return jresult;
16312 }
16313
16314
16315 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
16316   char * jresult ;
16317   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16318   std::string *result = 0 ;
16319
16320   arg1 = (Dali::BaseHandle *)jarg1;
16321   {
16322     try {
16323       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
16324     } catch (std::out_of_range& e) {
16325       {
16326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16327       };
16328     } catch (std::exception& e) {
16329       {
16330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16331       };
16332     } catch (...) {
16333       {
16334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16335       };
16336     }
16337   }
16338   jresult = SWIG_csharp_string_callback(result->c_str());
16339   return jresult;
16340 }
16341
16342
16343 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
16344   unsigned int jresult ;
16345   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16346   Dali::TypeInfo *arg2 = 0 ;
16347   bool result;
16348
16349   arg1 = (Dali::BaseHandle *)jarg1;
16350   arg2 = (Dali::TypeInfo *)jarg2;
16351   if (!arg2) {
16352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
16353     return 0;
16354   }
16355   {
16356     try {
16357       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
16358     } catch (std::out_of_range& e) {
16359       {
16360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16361       };
16362     } catch (std::exception& e) {
16363       {
16364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16365       };
16366     } catch (...) {
16367       {
16368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16369       };
16370     }
16371   }
16372   jresult = result;
16373   return jresult;
16374 }
16375
16376
16377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
16378   void * jresult ;
16379   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16380   Dali::BaseObject *result = 0 ;
16381
16382   arg1 = (Dali::BaseHandle *)jarg1;
16383   {
16384     try {
16385       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
16386     } catch (std::out_of_range& e) {
16387       {
16388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16389       };
16390     } catch (std::exception& e) {
16391       {
16392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16393       };
16394     } catch (...) {
16395       {
16396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16397       };
16398     }
16399   }
16400   jresult = (void *)result;
16401   return jresult;
16402 }
16403
16404
16405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
16406   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16407
16408   arg1 = (Dali::BaseHandle *)jarg1;
16409   {
16410     try {
16411       (arg1)->Reset();
16412     } catch (std::out_of_range& e) {
16413       {
16414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16415       };
16416     } catch (std::exception& e) {
16417       {
16418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16419       };
16420     } catch (...) {
16421       {
16422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16423       };
16424     }
16425   }
16426 }
16427
16428
16429 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
16430   unsigned int jresult ;
16431   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16432   Dali::BaseHandle *arg2 = 0 ;
16433   bool result;
16434
16435   arg1 = (Dali::BaseHandle *)jarg1;
16436   arg2 = (Dali::BaseHandle *)jarg2;
16437   if (!arg2) {
16438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16439     return 0;
16440   }
16441   {
16442     try {
16443       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
16444     } catch (std::out_of_range& e) {
16445       {
16446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16447       };
16448     } catch (std::exception& e) {
16449       {
16450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16451       };
16452     } catch (...) {
16453       {
16454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16455       };
16456     }
16457   }
16458   jresult = result;
16459   return jresult;
16460 }
16461
16462
16463 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
16464   unsigned int jresult ;
16465   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16466   Dali::BaseHandle *arg2 = 0 ;
16467   bool result;
16468
16469   arg1 = (Dali::BaseHandle *)jarg1;
16470   arg2 = (Dali::BaseHandle *)jarg2;
16471   if (!arg2) {
16472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16473     return 0;
16474   }
16475   {
16476     try {
16477       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
16478     } catch (std::out_of_range& e) {
16479       {
16480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16481       };
16482     } catch (std::exception& e) {
16483       {
16484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16485       };
16486     } catch (...) {
16487       {
16488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16489       };
16490     }
16491   }
16492   jresult = result;
16493   return jresult;
16494 }
16495
16496
16497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
16498   void * jresult ;
16499   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16500   Dali::RefObject *result = 0 ;
16501
16502   arg1 = (Dali::BaseHandle *)jarg1;
16503   {
16504     try {
16505       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
16506     } catch (std::out_of_range& e) {
16507       {
16508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16509       };
16510     } catch (std::exception& e) {
16511       {
16512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16513       };
16514     } catch (...) {
16515       {
16516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16517       };
16518     }
16519   }
16520   jresult = (void *)result;
16521   return jresult;
16522 }
16523
16524
16525 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
16526   unsigned int jresult ;
16527   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16528   bool result;
16529
16530   arg1 = (Dali::BaseHandle *)jarg1;
16531   {
16532     try {
16533       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
16534     } catch (std::out_of_range& e) {
16535       {
16536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16537       };
16538     } catch (std::exception& e) {
16539       {
16540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16541       };
16542     } catch (...) {
16543       {
16544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16545       };
16546     }
16547   }
16548   jresult = result;
16549   return jresult;
16550 }
16551
16552
16553 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
16554   unsigned int jresult ;
16555   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16556   Dali::BaseHandle *arg2 = 0 ;
16557   bool result;
16558
16559   arg1 = (Dali::BaseHandle *)jarg1;
16560   arg2 = (Dali::BaseHandle *)jarg2;
16561   if (!arg2) {
16562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16563     return 0;
16564   }
16565   {
16566     try {
16567       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
16568     } catch (std::out_of_range& e) {
16569       {
16570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16571       };
16572     } catch (std::exception& e) {
16573       {
16574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16575       };
16576     } catch (...) {
16577       {
16578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16579       };
16580     }
16581   }
16582   jresult = result;
16583   return jresult;
16584 }
16585
16586
16587 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
16588   unsigned int jresult ;
16589   Dali::BaseHandle *arg1 = 0 ;
16590   Dali::BaseHandle *arg2 = 0 ;
16591   bool result;
16592
16593   arg1 = (Dali::BaseHandle *)jarg1;
16594   if (!arg1) {
16595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16596     return 0;
16597   }
16598   arg2 = (Dali::BaseHandle *)jarg2;
16599   if (!arg2) {
16600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16601     return 0;
16602   }
16603   {
16604     try {
16605       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
16606     } catch (std::out_of_range& e) {
16607       {
16608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16609       };
16610     } catch (std::exception& e) {
16611       {
16612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16613       };
16614     } catch (...) {
16615       {
16616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16617       };
16618     }
16619   }
16620   jresult = result;
16621   return jresult;
16622 }
16623
16624
16625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
16626   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16627
16628   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16629   {
16630     try {
16631       delete arg1;
16632     } catch (std::out_of_range& e) {
16633       {
16634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16635       };
16636     } catch (std::exception& e) {
16637       {
16638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16639       };
16640     } catch (...) {
16641       {
16642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16643       };
16644     }
16645   }
16646 }
16647
16648
16649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16650   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16651   SlotObserver *arg2 = (SlotObserver *) 0 ;
16652   CallbackBase *arg3 = (CallbackBase *) 0 ;
16653
16654   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16655   arg2 = (SlotObserver *)jarg2;
16656   arg3 = (CallbackBase *)jarg3;
16657   {
16658     try {
16659       (arg1)->SignalConnected(arg2,arg3);
16660     } catch (std::out_of_range& e) {
16661       {
16662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16663       };
16664     } catch (std::exception& e) {
16665       {
16666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16667       };
16668     } catch (...) {
16669       {
16670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16671       };
16672     }
16673   }
16674 }
16675
16676
16677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
16678   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16679
16680   arg1 = (Dali::SignalObserver *)jarg1;
16681   {
16682     try {
16683       delete arg1;
16684     } catch (std::out_of_range& e) {
16685       {
16686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16687       };
16688     } catch (std::exception& e) {
16689       {
16690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16691       };
16692     } catch (...) {
16693       {
16694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16695       };
16696     }
16697   }
16698 }
16699
16700
16701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16702   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16703   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16704   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16705
16706   arg1 = (Dali::SignalObserver *)jarg1;
16707   arg2 = (Dali::SlotObserver *)jarg2;
16708   arg3 = (Dali::CallbackBase *)jarg3;
16709   {
16710     try {
16711       (arg1)->SignalDisconnected(arg2,arg3);
16712     } catch (std::out_of_range& e) {
16713       {
16714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16715       };
16716     } catch (std::exception& e) {
16717       {
16718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16719       };
16720     } catch (...) {
16721       {
16722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16723       };
16724     }
16725   }
16726 }
16727
16728
16729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
16730   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16731
16732   arg1 = (Dali::SlotObserver *)jarg1;
16733   {
16734     try {
16735       delete arg1;
16736     } catch (std::out_of_range& e) {
16737       {
16738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16739       };
16740     } catch (std::exception& e) {
16741       {
16742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16743       };
16744     } catch (...) {
16745       {
16746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16747       };
16748     }
16749   }
16750 }
16751
16752
16753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
16754   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16755   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
16756
16757   arg1 = (Dali::SlotObserver *)jarg1;
16758   arg2 = (Dali::CallbackBase *)jarg2;
16759   {
16760     try {
16761       (arg1)->SlotDisconnected(arg2);
16762     } catch (std::out_of_range& e) {
16763       {
16764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16765       };
16766     } catch (std::exception& e) {
16767       {
16768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16769       };
16770     } catch (...) {
16771       {
16772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16773       };
16774     }
16775   }
16776 }
16777
16778
16779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
16780   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16781
16782   arg1 = (Dali::ConnectionTracker *)jarg1;
16783   {
16784     try {
16785       delete arg1;
16786     } catch (std::out_of_range& e) {
16787       {
16788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16789       };
16790     } catch (std::exception& e) {
16791       {
16792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16793       };
16794     } catch (...) {
16795       {
16796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16797       };
16798     }
16799   }
16800 }
16801
16802
16803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
16804   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16805
16806   arg1 = (Dali::ConnectionTracker *)jarg1;
16807   {
16808     try {
16809       (arg1)->DisconnectAll();
16810     } catch (std::out_of_range& e) {
16811       {
16812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16813       };
16814     } catch (std::exception& e) {
16815       {
16816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16817       };
16818     } catch (...) {
16819       {
16820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16821       };
16822     }
16823   }
16824 }
16825
16826
16827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16828   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16829   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16830   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16831
16832   arg1 = (Dali::ConnectionTracker *)jarg1;
16833   arg2 = (Dali::SlotObserver *)jarg2;
16834   arg3 = (Dali::CallbackBase *)jarg3;
16835   {
16836     try {
16837       (arg1)->SignalConnected(arg2,arg3);
16838     } catch (std::out_of_range& e) {
16839       {
16840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16841       };
16842     } catch (std::exception& e) {
16843       {
16844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16845       };
16846     } catch (...) {
16847       {
16848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16849       };
16850     }
16851   }
16852 }
16853
16854
16855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16856   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16857   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16858   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16859
16860   arg1 = (Dali::ConnectionTracker *)jarg1;
16861   arg2 = (Dali::SlotObserver *)jarg2;
16862   arg3 = (Dali::CallbackBase *)jarg3;
16863   {
16864     try {
16865       (arg1)->SignalDisconnected(arg2,arg3);
16866     } catch (std::out_of_range& e) {
16867       {
16868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16869       };
16870     } catch (std::exception& e) {
16871       {
16872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16873       };
16874     } catch (...) {
16875       {
16876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16877       };
16878     }
16879   }
16880 }
16881
16882
16883 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
16884   unsigned long jresult ;
16885   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16886   std::size_t result;
16887
16888   arg1 = (Dali::ConnectionTracker *)jarg1;
16889   {
16890     try {
16891       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
16892     } catch (std::out_of_range& e) {
16893       {
16894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16895       };
16896     } catch (std::exception& e) {
16897       {
16898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16899       };
16900     } catch (...) {
16901       {
16902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16903       };
16904     }
16905   }
16906   jresult = (unsigned long)result;
16907   return jresult;
16908 }
16909
16910
16911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
16912   void * jresult ;
16913   Dali::ObjectRegistry *result = 0 ;
16914
16915   {
16916     try {
16917       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
16918     } catch (std::out_of_range& e) {
16919       {
16920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16921       };
16922     } catch (std::exception& e) {
16923       {
16924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16925       };
16926     } catch (...) {
16927       {
16928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16929       };
16930     }
16931   }
16932   jresult = (void *)result;
16933   return jresult;
16934 }
16935
16936
16937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
16938   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16939
16940   arg1 = (Dali::ObjectRegistry *)jarg1;
16941   {
16942     try {
16943       delete arg1;
16944     } catch (std::out_of_range& e) {
16945       {
16946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16947       };
16948     } catch (std::exception& e) {
16949       {
16950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16951       };
16952     } catch (...) {
16953       {
16954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16955       };
16956     }
16957   }
16958 }
16959
16960
16961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
16962   void * jresult ;
16963   Dali::ObjectRegistry *arg1 = 0 ;
16964   Dali::ObjectRegistry *result = 0 ;
16965
16966   arg1 = (Dali::ObjectRegistry *)jarg1;
16967   if (!arg1) {
16968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16969     return 0;
16970   }
16971   {
16972     try {
16973       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
16974     } catch (std::out_of_range& e) {
16975       {
16976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16977       };
16978     } catch (std::exception& e) {
16979       {
16980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16981       };
16982     } catch (...) {
16983       {
16984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16985       };
16986     }
16987   }
16988   jresult = (void *)result;
16989   return jresult;
16990 }
16991
16992
16993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
16994   void * jresult ;
16995   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16996   Dali::ObjectRegistry *arg2 = 0 ;
16997   Dali::ObjectRegistry *result = 0 ;
16998
16999   arg1 = (Dali::ObjectRegistry *)jarg1;
17000   arg2 = (Dali::ObjectRegistry *)jarg2;
17001   if (!arg2) {
17002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
17003     return 0;
17004   }
17005   {
17006     try {
17007       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
17008     } catch (std::out_of_range& e) {
17009       {
17010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17011       };
17012     } catch (std::exception& e) {
17013       {
17014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17015       };
17016     } catch (...) {
17017       {
17018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17019       };
17020     }
17021   }
17022   jresult = (void *)result;
17023   return jresult;
17024 }
17025
17026
17027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
17028   void * jresult ;
17029   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
17030   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
17031
17032   arg1 = (Dali::ObjectRegistry *)jarg1;
17033   {
17034     try {
17035       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
17036     } catch (std::out_of_range& e) {
17037       {
17038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17039       };
17040     } catch (std::exception& e) {
17041       {
17042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17043       };
17044     } catch (...) {
17045       {
17046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17047       };
17048     }
17049   }
17050   jresult = (void *)result;
17051   return jresult;
17052 }
17053
17054
17055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
17056   void * jresult ;
17057   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
17058   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
17059
17060   arg1 = (Dali::ObjectRegistry *)jarg1;
17061   {
17062     try {
17063       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
17064     } catch (std::out_of_range& e) {
17065       {
17066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17067       };
17068     } catch (std::exception& e) {
17069       {
17070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17071       };
17072     } catch (...) {
17073       {
17074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17075       };
17076     }
17077   }
17078   jresult = (void *)result;
17079   return jresult;
17080 }
17081
17082
17083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
17084   void * jresult ;
17085   Dali::PropertyCondition *result = 0 ;
17086
17087   {
17088     try {
17089       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
17090     } catch (std::out_of_range& e) {
17091       {
17092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17093       };
17094     } catch (std::exception& e) {
17095       {
17096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17097       };
17098     } catch (...) {
17099       {
17100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17101       };
17102     }
17103   }
17104   jresult = (void *)result;
17105   return jresult;
17106 }
17107
17108
17109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
17110   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17111
17112   arg1 = (Dali::PropertyCondition *)jarg1;
17113   {
17114     try {
17115       delete arg1;
17116     } catch (std::out_of_range& e) {
17117       {
17118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17119       };
17120     } catch (std::exception& e) {
17121       {
17122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17123       };
17124     } catch (...) {
17125       {
17126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17127       };
17128     }
17129   }
17130 }
17131
17132
17133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
17134   void * jresult ;
17135   Dali::PropertyCondition *arg1 = 0 ;
17136   Dali::PropertyCondition *result = 0 ;
17137
17138   arg1 = (Dali::PropertyCondition *)jarg1;
17139   if (!arg1) {
17140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17141     return 0;
17142   }
17143   {
17144     try {
17145       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
17146     } catch (std::out_of_range& e) {
17147       {
17148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17149       };
17150     } catch (std::exception& e) {
17151       {
17152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17153       };
17154     } catch (...) {
17155       {
17156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17157       };
17158     }
17159   }
17160   jresult = (void *)result;
17161   return jresult;
17162 }
17163
17164
17165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
17166   void * jresult ;
17167   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17168   Dali::PropertyCondition *arg2 = 0 ;
17169   Dali::PropertyCondition *result = 0 ;
17170
17171   arg1 = (Dali::PropertyCondition *)jarg1;
17172   arg2 = (Dali::PropertyCondition *)jarg2;
17173   if (!arg2) {
17174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17175     return 0;
17176   }
17177   {
17178     try {
17179       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
17180     } catch (std::out_of_range& e) {
17181       {
17182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17183       };
17184     } catch (std::exception& e) {
17185       {
17186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17187       };
17188     } catch (...) {
17189       {
17190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17191       };
17192     }
17193   }
17194   jresult = (void *)result;
17195   return jresult;
17196 }
17197
17198
17199 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
17200   unsigned long jresult ;
17201   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17202   std::size_t result;
17203
17204   arg1 = (Dali::PropertyCondition *)jarg1;
17205   {
17206     try {
17207       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
17208     } catch (std::out_of_range& e) {
17209       {
17210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17211       };
17212     } catch (std::exception& e) {
17213       {
17214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17215       };
17216     } catch (...) {
17217       {
17218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17219       };
17220     }
17221   }
17222   jresult = (unsigned long)result;
17223   return jresult;
17224 }
17225
17226
17227 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
17228   float jresult ;
17229   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17230   std::size_t arg2 ;
17231   float result;
17232
17233   arg1 = (Dali::PropertyCondition *)jarg1;
17234   arg2 = (std::size_t)jarg2;
17235   {
17236     try {
17237       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
17238     } catch (std::out_of_range& e) {
17239       {
17240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17241       };
17242     } catch (std::exception& e) {
17243       {
17244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17245       };
17246     } catch (...) {
17247       {
17248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17249       };
17250     }
17251   }
17252   jresult = result;
17253   return jresult;
17254 }
17255
17256
17257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
17258   void * jresult ;
17259   float arg1 ;
17260   Dali::PropertyCondition result;
17261
17262   arg1 = (float)jarg1;
17263   {
17264     try {
17265       result = Dali::LessThanCondition(arg1);
17266     } catch (std::out_of_range& e) {
17267       {
17268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17269       };
17270     } catch (std::exception& e) {
17271       {
17272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17273       };
17274     } catch (...) {
17275       {
17276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17277       };
17278     }
17279   }
17280   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17281   return jresult;
17282 }
17283
17284
17285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
17286   void * jresult ;
17287   float arg1 ;
17288   Dali::PropertyCondition result;
17289
17290   arg1 = (float)jarg1;
17291   {
17292     try {
17293       result = Dali::GreaterThanCondition(arg1);
17294     } catch (std::out_of_range& e) {
17295       {
17296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17297       };
17298     } catch (std::exception& e) {
17299       {
17300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17301       };
17302     } catch (...) {
17303       {
17304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17305       };
17306     }
17307   }
17308   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17309   return jresult;
17310 }
17311
17312
17313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
17314   void * jresult ;
17315   float arg1 ;
17316   float arg2 ;
17317   Dali::PropertyCondition result;
17318
17319   arg1 = (float)jarg1;
17320   arg2 = (float)jarg2;
17321   {
17322     try {
17323       result = Dali::InsideCondition(arg1,arg2);
17324     } catch (std::out_of_range& e) {
17325       {
17326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17327       };
17328     } catch (std::exception& e) {
17329       {
17330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17331       };
17332     } catch (...) {
17333       {
17334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17335       };
17336     }
17337   }
17338   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17339   return jresult;
17340 }
17341
17342
17343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
17344   void * jresult ;
17345   float arg1 ;
17346   float arg2 ;
17347   Dali::PropertyCondition result;
17348
17349   arg1 = (float)jarg1;
17350   arg2 = (float)jarg2;
17351   {
17352     try {
17353       result = Dali::OutsideCondition(arg1,arg2);
17354     } catch (std::out_of_range& e) {
17355       {
17356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17357       };
17358     } catch (std::exception& e) {
17359       {
17360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17361       };
17362     } catch (...) {
17363       {
17364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17365       };
17366     }
17367   }
17368   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17369   return jresult;
17370 }
17371
17372
17373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
17374   void * jresult ;
17375   float arg1 ;
17376   float arg2 ;
17377   Dali::PropertyCondition result;
17378
17379   arg1 = (float)jarg1;
17380   arg2 = (float)jarg2;
17381   {
17382     try {
17383       result = Dali::StepCondition(arg1,arg2);
17384     } catch (std::out_of_range& e) {
17385       {
17386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17387       };
17388     } catch (std::exception& e) {
17389       {
17390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17391       };
17392     } catch (...) {
17393       {
17394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17395       };
17396     }
17397   }
17398   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17399   return jresult;
17400 }
17401
17402
17403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
17404   void * jresult ;
17405   float arg1 ;
17406   Dali::PropertyCondition result;
17407
17408   arg1 = (float)jarg1;
17409   {
17410     try {
17411       result = Dali::StepCondition(arg1);
17412     } catch (std::out_of_range& e) {
17413       {
17414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17415       };
17416     } catch (std::exception& e) {
17417       {
17418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17419       };
17420     } catch (...) {
17421       {
17422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17423       };
17424     }
17425   }
17426   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17427   return jresult;
17428 }
17429
17430
17431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
17432   void * jresult ;
17433   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
17434   Dali::PropertyCondition result;
17435
17436   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
17437   if (!arg1) {
17438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
17439     return 0;
17440   }
17441   {
17442     try {
17443       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
17444     } catch (std::out_of_range& e) {
17445       {
17446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17447       };
17448     } catch (std::exception& e) {
17449       {
17450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17451       };
17452     } catch (...) {
17453       {
17454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17455       };
17456     }
17457   }
17458   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17459   return jresult;
17460 }
17461
17462
17463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
17464   void * jresult ;
17465   Dali::PropertyNotification *result = 0 ;
17466
17467   {
17468     try {
17469       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
17470     } catch (std::out_of_range& e) {
17471       {
17472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17473       };
17474     } catch (std::exception& e) {
17475       {
17476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17477       };
17478     } catch (...) {
17479       {
17480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17481       };
17482     }
17483   }
17484   jresult = (void *)result;
17485   return jresult;
17486 }
17487
17488
17489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
17490   void * jresult ;
17491   Dali::BaseHandle arg1 ;
17492   Dali::BaseHandle *argp1 ;
17493   Dali::PropertyNotification result;
17494
17495   argp1 = (Dali::BaseHandle *)jarg1;
17496   if (!argp1) {
17497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17498     return 0;
17499   }
17500   arg1 = *argp1;
17501   {
17502     try {
17503       result = Dali::PropertyNotification::DownCast(arg1);
17504     } catch (std::out_of_range& e) {
17505       {
17506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17507       };
17508     } catch (std::exception& e) {
17509       {
17510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17511       };
17512     } catch (...) {
17513       {
17514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17515       };
17516     }
17517   }
17518   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
17519   return jresult;
17520 }
17521
17522
17523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
17524   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17525
17526   arg1 = (Dali::PropertyNotification *)jarg1;
17527   {
17528     try {
17529       delete arg1;
17530     } catch (std::out_of_range& e) {
17531       {
17532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17533       };
17534     } catch (std::exception& e) {
17535       {
17536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17537       };
17538     } catch (...) {
17539       {
17540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17541       };
17542     }
17543   }
17544 }
17545
17546
17547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
17548   void * jresult ;
17549   Dali::PropertyNotification *arg1 = 0 ;
17550   Dali::PropertyNotification *result = 0 ;
17551
17552   arg1 = (Dali::PropertyNotification *)jarg1;
17553   if (!arg1) {
17554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17555     return 0;
17556   }
17557   {
17558     try {
17559       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
17560     } catch (std::out_of_range& e) {
17561       {
17562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17563       };
17564     } catch (std::exception& e) {
17565       {
17566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17567       };
17568     } catch (...) {
17569       {
17570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17571       };
17572     }
17573   }
17574   jresult = (void *)result;
17575   return jresult;
17576 }
17577
17578
17579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
17580   void * jresult ;
17581   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17582   Dali::PropertyNotification *arg2 = 0 ;
17583   Dali::PropertyNotification *result = 0 ;
17584
17585   arg1 = (Dali::PropertyNotification *)jarg1;
17586   arg2 = (Dali::PropertyNotification *)jarg2;
17587   if (!arg2) {
17588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17589     return 0;
17590   }
17591   {
17592     try {
17593       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
17594     } catch (std::out_of_range& e) {
17595       {
17596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17597       };
17598     } catch (std::exception& e) {
17599       {
17600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17601       };
17602     } catch (...) {
17603       {
17604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17605       };
17606     }
17607   }
17608   jresult = (void *)result;
17609   return jresult;
17610 }
17611
17612
17613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
17614   void * jresult ;
17615   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17616   Dali::PropertyCondition result;
17617
17618   arg1 = (Dali::PropertyNotification *)jarg1;
17619   {
17620     try {
17621       result = (arg1)->GetCondition();
17622     } catch (std::out_of_range& e) {
17623       {
17624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17625       };
17626     } catch (std::exception& e) {
17627       {
17628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17629       };
17630     } catch (...) {
17631       {
17632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17633       };
17634     }
17635   }
17636   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17637   return jresult;
17638 }
17639
17640
17641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
17642   void * jresult ;
17643   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17644   Dali::Handle result;
17645
17646   arg1 = (Dali::PropertyNotification *)jarg1;
17647   {
17648     try {
17649       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
17650     } catch (std::out_of_range& e) {
17651       {
17652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17653       };
17654     } catch (std::exception& e) {
17655       {
17656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17657       };
17658     } catch (...) {
17659       {
17660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17661       };
17662     }
17663   }
17664   jresult = new Dali::Handle((const Dali::Handle &)result);
17665   return jresult;
17666 }
17667
17668
17669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
17670   int jresult ;
17671   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17672   Dali::Property::Index result;
17673
17674   arg1 = (Dali::PropertyNotification *)jarg1;
17675   {
17676     try {
17677       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
17678     } catch (std::out_of_range& e) {
17679       {
17680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17681       };
17682     } catch (std::exception& e) {
17683       {
17684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17685       };
17686     } catch (...) {
17687       {
17688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17689       };
17690     }
17691   }
17692   jresult = result;
17693   return jresult;
17694 }
17695
17696
17697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
17698   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17699   Dali::PropertyNotification::NotifyMode arg2 ;
17700
17701   arg1 = (Dali::PropertyNotification *)jarg1;
17702   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
17703   {
17704     try {
17705       (arg1)->SetNotifyMode(arg2);
17706     } catch (std::out_of_range& e) {
17707       {
17708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17709       };
17710     } catch (std::exception& e) {
17711       {
17712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17713       };
17714     } catch (...) {
17715       {
17716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17717       };
17718     }
17719   }
17720 }
17721
17722
17723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
17724   int jresult ;
17725   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17726   Dali::PropertyNotification::NotifyMode result;
17727
17728   arg1 = (Dali::PropertyNotification *)jarg1;
17729   {
17730     try {
17731       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
17732     } catch (std::out_of_range& e) {
17733       {
17734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17735       };
17736     } catch (std::exception& e) {
17737       {
17738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17739       };
17740     } catch (...) {
17741       {
17742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17743       };
17744     }
17745   }
17746   jresult = (int)result;
17747   return jresult;
17748 }
17749
17750
17751 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
17752   unsigned int jresult ;
17753   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17754   bool result;
17755
17756   arg1 = (Dali::PropertyNotification *)jarg1;
17757   {
17758     try {
17759       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
17760     } catch (std::out_of_range& e) {
17761       {
17762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17763       };
17764     } catch (std::exception& e) {
17765       {
17766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17767       };
17768     } catch (...) {
17769       {
17770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17771       };
17772     }
17773   }
17774   jresult = result;
17775   return jresult;
17776 }
17777
17778
17779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
17780   void * jresult ;
17781   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17782   Dali::PropertyNotifySignalType *result = 0 ;
17783
17784   arg1 = (Dali::PropertyNotification *)jarg1;
17785   {
17786     try {
17787       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
17788     } catch (std::out_of_range& e) {
17789       {
17790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17791       };
17792     } catch (std::exception& e) {
17793       {
17794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17795       };
17796     } catch (...) {
17797       {
17798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17799       };
17800     }
17801   }
17802   jresult = (void *)result;
17803   return jresult;
17804 }
17805
17806
17807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
17808   void * jresult ;
17809   Dali::Handle *result = 0 ;
17810
17811   {
17812     try {
17813       result = (Dali::Handle *)new Dali::Handle();
17814     } catch (std::out_of_range& e) {
17815       {
17816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17817       };
17818     } catch (std::exception& e) {
17819       {
17820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17821       };
17822     } catch (...) {
17823       {
17824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17825       };
17826     }
17827   }
17828   jresult = (void *)result;
17829   return jresult;
17830 }
17831
17832
17833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
17834   void * jresult ;
17835   Dali::Handle result;
17836
17837   {
17838     try {
17839       result = Dali::Handle::New();
17840     } catch (std::out_of_range& e) {
17841       {
17842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17843       };
17844     } catch (std::exception& e) {
17845       {
17846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17847       };
17848     } catch (...) {
17849       {
17850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17851       };
17852     }
17853   }
17854   jresult = new Dali::Handle((const Dali::Handle &)result);
17855   return jresult;
17856 }
17857
17858
17859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
17860   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17861
17862   arg1 = (Dali::Handle *)jarg1;
17863   {
17864     try {
17865       delete arg1;
17866     } catch (std::out_of_range& e) {
17867       {
17868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17869       };
17870     } catch (std::exception& e) {
17871       {
17872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17873       };
17874     } catch (...) {
17875       {
17876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17877       };
17878     }
17879   }
17880 }
17881
17882
17883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
17884   void * jresult ;
17885   Dali::Handle *arg1 = 0 ;
17886   Dali::Handle *result = 0 ;
17887
17888   arg1 = (Dali::Handle *)jarg1;
17889   if (!arg1) {
17890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17891     return 0;
17892   }
17893   {
17894     try {
17895       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
17896     } catch (std::out_of_range& e) {
17897       {
17898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17899       };
17900     } catch (std::exception& e) {
17901       {
17902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17903       };
17904     } catch (...) {
17905       {
17906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17907       };
17908     }
17909   }
17910   jresult = (void *)result;
17911   return jresult;
17912 }
17913
17914
17915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
17916   void * jresult ;
17917   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17918   Dali::Handle *arg2 = 0 ;
17919   Dali::Handle *result = 0 ;
17920
17921   arg1 = (Dali::Handle *)jarg1;
17922   arg2 = (Dali::Handle *)jarg2;
17923   if (!arg2) {
17924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17925     return 0;
17926   }
17927   {
17928     try {
17929       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
17930     } catch (std::out_of_range& e) {
17931       {
17932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17933       };
17934     } catch (std::exception& e) {
17935       {
17936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17937       };
17938     } catch (...) {
17939       {
17940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17941       };
17942     }
17943   }
17944   jresult = (void *)result;
17945   return jresult;
17946 }
17947
17948
17949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
17950   void * jresult ;
17951   Dali::BaseHandle arg1 ;
17952   Dali::BaseHandle *argp1 ;
17953   Dali::Handle result;
17954
17955   argp1 = (Dali::BaseHandle *)jarg1;
17956   if (!argp1) {
17957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17958     return 0;
17959   }
17960   arg1 = *argp1;
17961   {
17962     try {
17963       result = Dali::Handle::DownCast(arg1);
17964     } catch (std::out_of_range& e) {
17965       {
17966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17967       };
17968     } catch (std::exception& e) {
17969       {
17970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17971       };
17972     } catch (...) {
17973       {
17974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17975       };
17976     }
17977   }
17978   jresult = new Dali::Handle((const Dali::Handle &)result);
17979   return jresult;
17980 }
17981
17982
17983 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
17984   unsigned int jresult ;
17985   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17986   Dali::Handle::Capability arg2 ;
17987   bool result;
17988
17989   arg1 = (Dali::Handle *)jarg1;
17990   arg2 = (Dali::Handle::Capability)jarg2;
17991   {
17992     try {
17993       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
17994     } catch (std::out_of_range& e) {
17995       {
17996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17997       };
17998     } catch (std::exception& e) {
17999       {
18000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18001       };
18002     } catch (...) {
18003       {
18004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18005       };
18006     }
18007   }
18008   jresult = result;
18009   return jresult;
18010 }
18011
18012
18013 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
18014   unsigned int jresult ;
18015   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18016   unsigned int result;
18017
18018   arg1 = (Dali::Handle *)jarg1;
18019   {
18020     try {
18021       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
18022     } catch (std::out_of_range& e) {
18023       {
18024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18025       };
18026     } catch (std::exception& e) {
18027       {
18028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18029       };
18030     } catch (...) {
18031       {
18032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18033       };
18034     }
18035   }
18036   jresult = result;
18037   return jresult;
18038 }
18039
18040
18041 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
18042   char * jresult ;
18043   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18044   Dali::Property::Index arg2 ;
18045   std::string result;
18046
18047   arg1 = (Dali::Handle *)jarg1;
18048   arg2 = (Dali::Property::Index)jarg2;
18049   {
18050     try {
18051       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
18052     } catch (std::out_of_range& e) {
18053       {
18054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18055       };
18056     } catch (std::exception& e) {
18057       {
18058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18059       };
18060     } catch (...) {
18061       {
18062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18063       };
18064     }
18065   }
18066   jresult = SWIG_csharp_string_callback((&result)->c_str());
18067   return jresult;
18068 }
18069
18070
18071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
18072   int jresult ;
18073   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18074   std::string *arg2 = 0 ;
18075   Dali::Property::Index result;
18076
18077   arg1 = (Dali::Handle *)jarg1;
18078   if (!jarg2) {
18079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18080     return 0;
18081   }
18082   std::string arg2_str(jarg2);
18083   arg2 = &arg2_str;
18084   {
18085     try {
18086       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
18087     } catch (std::out_of_range& e) {
18088       {
18089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18090       };
18091     } catch (std::exception& e) {
18092       {
18093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18094       };
18095     } catch (...) {
18096       {
18097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18098       };
18099     }
18100   }
18101   jresult = result;
18102
18103   //argout typemap for const std::string&
18104
18105   return jresult;
18106 }
18107
18108
18109 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
18110   unsigned int jresult ;
18111   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18112   Dali::Property::Index arg2 ;
18113   bool result;
18114
18115   arg1 = (Dali::Handle *)jarg1;
18116   arg2 = (Dali::Property::Index)jarg2;
18117   {
18118     try {
18119       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
18120     } catch (std::out_of_range& e) {
18121       {
18122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18123       };
18124     } catch (std::exception& e) {
18125       {
18126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18127       };
18128     } catch (...) {
18129       {
18130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18131       };
18132     }
18133   }
18134   jresult = result;
18135   return jresult;
18136 }
18137
18138
18139 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
18140   unsigned int jresult ;
18141   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18142   Dali::Property::Index arg2 ;
18143   bool result;
18144
18145   arg1 = (Dali::Handle *)jarg1;
18146   arg2 = (Dali::Property::Index)jarg2;
18147   {
18148     try {
18149       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
18150     } catch (std::out_of_range& e) {
18151       {
18152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18153       };
18154     } catch (std::exception& e) {
18155       {
18156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18157       };
18158     } catch (...) {
18159       {
18160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18161       };
18162     }
18163   }
18164   jresult = result;
18165   return jresult;
18166 }
18167
18168
18169 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
18170   unsigned int jresult ;
18171   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18172   Dali::Property::Index arg2 ;
18173   bool result;
18174
18175   arg1 = (Dali::Handle *)jarg1;
18176   arg2 = (Dali::Property::Index)jarg2;
18177   {
18178     try {
18179       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
18180     } catch (std::out_of_range& e) {
18181       {
18182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18183       };
18184     } catch (std::exception& e) {
18185       {
18186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18187       };
18188     } catch (...) {
18189       {
18190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18191       };
18192     }
18193   }
18194   jresult = result;
18195   return jresult;
18196 }
18197
18198
18199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
18200   int jresult ;
18201   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18202   Dali::Property::Index arg2 ;
18203   Dali::Property::Type result;
18204
18205   arg1 = (Dali::Handle *)jarg1;
18206   arg2 = (Dali::Property::Index)jarg2;
18207   {
18208     try {
18209       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
18210     } catch (std::out_of_range& e) {
18211       {
18212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18213       };
18214     } catch (std::exception& e) {
18215       {
18216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18217       };
18218     } catch (...) {
18219       {
18220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18221       };
18222     }
18223   }
18224   jresult = (int)result;
18225   return jresult;
18226 }
18227
18228
18229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
18230   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18231   Dali::Property::Index arg2 ;
18232   Dali::Property::Value *arg3 = 0 ;
18233
18234   arg1 = (Dali::Handle *)jarg1;
18235   arg2 = (Dali::Property::Index)jarg2;
18236   arg3 = (Dali::Property::Value *)jarg3;
18237   if (!arg3) {
18238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18239     return ;
18240   }
18241   {
18242     try {
18243       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
18244     } catch (std::out_of_range& e) {
18245       {
18246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18247       };
18248     } catch (std::exception& e) {
18249       {
18250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18251       };
18252     } catch (...) {
18253       {
18254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18255       };
18256     }
18257   }
18258 }
18259
18260
18261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
18262   int jresult ;
18263   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18264   std::string *arg2 = 0 ;
18265   Dali::Property::Value *arg3 = 0 ;
18266   Dali::Property::Index result;
18267
18268   arg1 = (Dali::Handle *)jarg1;
18269   if (!jarg2) {
18270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18271     return 0;
18272   }
18273   std::string arg2_str(jarg2);
18274   arg2 = &arg2_str;
18275   arg3 = (Dali::Property::Value *)jarg3;
18276   if (!arg3) {
18277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18278     return 0;
18279   }
18280   {
18281     try {
18282       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
18283     } catch (std::out_of_range& e) {
18284       {
18285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18286       };
18287     } catch (std::exception& e) {
18288       {
18289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18290       };
18291     } catch (...) {
18292       {
18293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18294       };
18295     }
18296   }
18297   jresult = result;
18298
18299   //argout typemap for const std::string&
18300
18301   return jresult;
18302 }
18303
18304
18305 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
18306   int jresult ;
18307   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18308   std::string *arg2 = 0 ;
18309   Dali::Property::Value *arg3 = 0 ;
18310   Dali::Property::AccessMode arg4 ;
18311   Dali::Property::Index result;
18312
18313   arg1 = (Dali::Handle *)jarg1;
18314   if (!jarg2) {
18315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18316     return 0;
18317   }
18318   std::string arg2_str(jarg2);
18319   arg2 = &arg2_str;
18320   arg3 = (Dali::Property::Value *)jarg3;
18321   if (!arg3) {
18322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18323     return 0;
18324   }
18325   arg4 = (Dali::Property::AccessMode)jarg4;
18326   {
18327     try {
18328       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
18329     } catch (std::out_of_range& e) {
18330       {
18331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18332       };
18333     } catch (std::exception& e) {
18334       {
18335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18336       };
18337     } catch (...) {
18338       {
18339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18340       };
18341     }
18342   }
18343   jresult = result;
18344
18345   //argout typemap for const std::string&
18346
18347   return jresult;
18348 }
18349
18350
18351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
18352   void * jresult ;
18353   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18354   Dali::Property::Index arg2 ;
18355   Dali::Property::Value result;
18356
18357   arg1 = (Dali::Handle *)jarg1;
18358   arg2 = (Dali::Property::Index)jarg2;
18359   {
18360     try {
18361       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
18362     } catch (std::out_of_range& e) {
18363       {
18364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18365       };
18366     } catch (std::exception& e) {
18367       {
18368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18369       };
18370     } catch (...) {
18371       {
18372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18373       };
18374     }
18375   }
18376   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
18377   return jresult;
18378 }
18379
18380
18381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
18382   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18383   Dali::Property::IndexContainer *arg2 = 0 ;
18384
18385   arg1 = (Dali::Handle *)jarg1;
18386   arg2 = (Dali::Property::IndexContainer *)jarg2;
18387   if (!arg2) {
18388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18389     return ;
18390   }
18391   {
18392     try {
18393       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
18394     } catch (std::out_of_range& e) {
18395       {
18396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18397       };
18398     } catch (std::exception& e) {
18399       {
18400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18401       };
18402     } catch (...) {
18403       {
18404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18405       };
18406     }
18407   }
18408 }
18409
18410
18411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
18412   void * jresult ;
18413   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18414   Dali::Property::Index arg2 ;
18415   Dali::PropertyCondition *arg3 = 0 ;
18416   Dali::PropertyNotification result;
18417
18418   arg1 = (Dali::Handle *)jarg1;
18419   arg2 = (Dali::Property::Index)jarg2;
18420   arg3 = (Dali::PropertyCondition *)jarg3;
18421   if (!arg3) {
18422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18423     return 0;
18424   }
18425   {
18426     try {
18427       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
18428     } catch (std::out_of_range& e) {
18429       {
18430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18431       };
18432     } catch (std::exception& e) {
18433       {
18434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18435       };
18436     } catch (...) {
18437       {
18438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18439       };
18440     }
18441   }
18442   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18443   return jresult;
18444 }
18445
18446
18447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
18448   void * jresult ;
18449   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18450   Dali::Property::Index arg2 ;
18451   int arg3 ;
18452   Dali::PropertyCondition *arg4 = 0 ;
18453   Dali::PropertyNotification result;
18454
18455   arg1 = (Dali::Handle *)jarg1;
18456   arg2 = (Dali::Property::Index)jarg2;
18457   arg3 = (int)jarg3;
18458   arg4 = (Dali::PropertyCondition *)jarg4;
18459   if (!arg4) {
18460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18461     return 0;
18462   }
18463   {
18464     try {
18465       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
18466     } catch (std::out_of_range& e) {
18467       {
18468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18469       };
18470     } catch (std::exception& e) {
18471       {
18472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18473       };
18474     } catch (...) {
18475       {
18476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18477       };
18478     }
18479   }
18480   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18481   return jresult;
18482 }
18483
18484
18485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
18486   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18487   Dali::PropertyNotification arg2 ;
18488   Dali::PropertyNotification *argp2 ;
18489
18490   arg1 = (Dali::Handle *)jarg1;
18491   argp2 = (Dali::PropertyNotification *)jarg2;
18492   if (!argp2) {
18493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
18494     return ;
18495   }
18496   arg2 = *argp2;
18497   {
18498     try {
18499       (arg1)->RemovePropertyNotification(arg2);
18500     } catch (std::out_of_range& e) {
18501       {
18502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18503       };
18504     } catch (std::exception& e) {
18505       {
18506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18507       };
18508     } catch (...) {
18509       {
18510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18511       };
18512     }
18513   }
18514 }
18515
18516
18517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
18518   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18519
18520   arg1 = (Dali::Handle *)jarg1;
18521   {
18522     try {
18523       (arg1)->RemovePropertyNotifications();
18524     } catch (std::out_of_range& e) {
18525       {
18526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18527       };
18528     } catch (std::exception& e) {
18529       {
18530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18531       };
18532     } catch (...) {
18533       {
18534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18535       };
18536     }
18537   }
18538 }
18539
18540
18541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
18542   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18543
18544   arg1 = (Dali::Handle *)jarg1;
18545   {
18546     try {
18547       (arg1)->RemoveConstraints();
18548     } catch (std::out_of_range& e) {
18549       {
18550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18551       };
18552     } catch (std::exception& e) {
18553       {
18554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18555       };
18556     } catch (...) {
18557       {
18558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18559       };
18560     }
18561   }
18562 }
18563
18564
18565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
18566   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18567   unsigned int arg2 ;
18568
18569   arg1 = (Dali::Handle *)jarg1;
18570   arg2 = (unsigned int)jarg2;
18571   {
18572     try {
18573       (arg1)->RemoveConstraints(arg2);
18574     } catch (std::out_of_range& e) {
18575       {
18576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18577       };
18578     } catch (std::exception& e) {
18579       {
18580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18581       };
18582     } catch (...) {
18583       {
18584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18585       };
18586     }
18587   }
18588 }
18589
18590
18591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
18592   int jresult ;
18593   Dali::Property::Index result;
18594
18595   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
18596   jresult = result;
18597   return jresult;
18598 }
18599
18600
18601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
18602   void * jresult ;
18603   Dali::Handle result;
18604
18605   {
18606     try {
18607       result = Dali::WeightObject::New();
18608     } catch (std::out_of_range& e) {
18609       {
18610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18611       };
18612     } catch (std::exception& e) {
18613       {
18614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18615       };
18616     } catch (...) {
18617       {
18618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18619       };
18620     }
18621   }
18622   jresult = new Dali::Handle((const Dali::Handle &)result);
18623   return jresult;
18624 }
18625
18626
18627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
18628   void * jresult ;
18629   Dali::TypeInfo *result = 0 ;
18630
18631   {
18632     try {
18633       result = (Dali::TypeInfo *)new Dali::TypeInfo();
18634     } catch (std::out_of_range& e) {
18635       {
18636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18637       };
18638     } catch (std::exception& e) {
18639       {
18640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18641       };
18642     } catch (...) {
18643       {
18644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18645       };
18646     }
18647   }
18648   jresult = (void *)result;
18649   return jresult;
18650 }
18651
18652
18653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
18654   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18655
18656   arg1 = (Dali::TypeInfo *)jarg1;
18657   {
18658     try {
18659       delete arg1;
18660     } catch (std::out_of_range& e) {
18661       {
18662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18663       };
18664     } catch (std::exception& e) {
18665       {
18666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18667       };
18668     } catch (...) {
18669       {
18670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18671       };
18672     }
18673   }
18674 }
18675
18676
18677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
18678   void * jresult ;
18679   Dali::TypeInfo *arg1 = 0 ;
18680   Dali::TypeInfo *result = 0 ;
18681
18682   arg1 = (Dali::TypeInfo *)jarg1;
18683   if (!arg1) {
18684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18685     return 0;
18686   }
18687   {
18688     try {
18689       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
18690     } catch (std::out_of_range& e) {
18691       {
18692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18693       };
18694     } catch (std::exception& e) {
18695       {
18696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18697       };
18698     } catch (...) {
18699       {
18700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18701       };
18702     }
18703   }
18704   jresult = (void *)result;
18705   return jresult;
18706 }
18707
18708
18709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
18710   void * jresult ;
18711   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18712   Dali::TypeInfo *arg2 = 0 ;
18713   Dali::TypeInfo *result = 0 ;
18714
18715   arg1 = (Dali::TypeInfo *)jarg1;
18716   arg2 = (Dali::TypeInfo *)jarg2;
18717   if (!arg2) {
18718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18719     return 0;
18720   }
18721   {
18722     try {
18723       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
18724     } catch (std::out_of_range& e) {
18725       {
18726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18727       };
18728     } catch (std::exception& e) {
18729       {
18730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18731       };
18732     } catch (...) {
18733       {
18734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18735       };
18736     }
18737   }
18738   jresult = (void *)result;
18739   return jresult;
18740 }
18741
18742
18743 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
18744   char * jresult ;
18745   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18746   std::string *result = 0 ;
18747
18748   arg1 = (Dali::TypeInfo *)jarg1;
18749   {
18750     try {
18751       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
18752     } catch (std::out_of_range& e) {
18753       {
18754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18755       };
18756     } catch (std::exception& e) {
18757       {
18758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18759       };
18760     } catch (...) {
18761       {
18762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18763       };
18764     }
18765   }
18766   jresult = SWIG_csharp_string_callback(result->c_str());
18767   return jresult;
18768 }
18769
18770
18771 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
18772   char * jresult ;
18773   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18774   std::string *result = 0 ;
18775
18776   arg1 = (Dali::TypeInfo *)jarg1;
18777   {
18778     try {
18779       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
18780     } catch (std::out_of_range& e) {
18781       {
18782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18783       };
18784     } catch (std::exception& e) {
18785       {
18786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18787       };
18788     } catch (...) {
18789       {
18790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18791       };
18792     }
18793   }
18794   jresult = SWIG_csharp_string_callback(result->c_str());
18795   return jresult;
18796 }
18797
18798
18799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
18800   void * jresult ;
18801   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18802   Dali::BaseHandle result;
18803
18804   arg1 = (Dali::TypeInfo *)jarg1;
18805   {
18806     try {
18807       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
18808     } catch (std::out_of_range& e) {
18809       {
18810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18811       };
18812     } catch (std::exception& e) {
18813       {
18814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18815       };
18816     } catch (...) {
18817       {
18818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18819       };
18820     }
18821   }
18822   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
18823   return jresult;
18824 }
18825
18826
18827 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
18828   unsigned long jresult ;
18829   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18830   size_t result;
18831
18832   arg1 = (Dali::TypeInfo *)jarg1;
18833   {
18834     try {
18835       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
18836     } catch (std::out_of_range& e) {
18837       {
18838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18839       };
18840     } catch (std::exception& e) {
18841       {
18842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18843       };
18844     } catch (...) {
18845       {
18846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18847       };
18848     }
18849   }
18850   jresult = (unsigned long)result;
18851   return jresult;
18852 }
18853
18854
18855 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
18856   char * jresult ;
18857   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18858   size_t arg2 ;
18859   std::string result;
18860
18861   arg1 = (Dali::TypeInfo *)jarg1;
18862   arg2 = (size_t)jarg2;
18863   {
18864     try {
18865       result = (arg1)->GetActionName(arg2);
18866     } catch (std::out_of_range& e) {
18867       {
18868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18869       };
18870     } catch (std::exception& e) {
18871       {
18872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18873       };
18874     } catch (...) {
18875       {
18876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18877       };
18878     }
18879   }
18880   jresult = SWIG_csharp_string_callback((&result)->c_str());
18881   return jresult;
18882 }
18883
18884
18885 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
18886   unsigned long jresult ;
18887   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18888   size_t result;
18889
18890   arg1 = (Dali::TypeInfo *)jarg1;
18891   {
18892     try {
18893       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
18894     } catch (std::out_of_range& e) {
18895       {
18896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18897       };
18898     } catch (std::exception& e) {
18899       {
18900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18901       };
18902     } catch (...) {
18903       {
18904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18905       };
18906     }
18907   }
18908   jresult = (unsigned long)result;
18909   return jresult;
18910 }
18911
18912
18913 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
18914   char * jresult ;
18915   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18916   size_t arg2 ;
18917   std::string result;
18918
18919   arg1 = (Dali::TypeInfo *)jarg1;
18920   arg2 = (size_t)jarg2;
18921   {
18922     try {
18923       result = (arg1)->GetSignalName(arg2);
18924     } catch (std::out_of_range& e) {
18925       {
18926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18927       };
18928     } catch (std::exception& e) {
18929       {
18930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18931       };
18932     } catch (...) {
18933       {
18934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18935       };
18936     }
18937   }
18938   jresult = SWIG_csharp_string_callback((&result)->c_str());
18939   return jresult;
18940 }
18941
18942
18943 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
18944   unsigned long jresult ;
18945   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18946   size_t result;
18947
18948   arg1 = (Dali::TypeInfo *)jarg1;
18949   {
18950     try {
18951       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
18952     } catch (std::out_of_range& e) {
18953       {
18954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18955       };
18956     } catch (std::exception& e) {
18957       {
18958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18959       };
18960     } catch (...) {
18961       {
18962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18963       };
18964     }
18965   }
18966   jresult = (unsigned long)result;
18967   return jresult;
18968 }
18969
18970
18971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
18972   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18973   Dali::Property::IndexContainer *arg2 = 0 ;
18974
18975   arg1 = (Dali::TypeInfo *)jarg1;
18976   arg2 = (Dali::Property::IndexContainer *)jarg2;
18977   if (!arg2) {
18978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18979     return ;
18980   }
18981   {
18982     try {
18983       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
18984     } catch (std::out_of_range& e) {
18985       {
18986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18987       };
18988     } catch (std::exception& e) {
18989       {
18990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18991       };
18992     } catch (...) {
18993       {
18994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18995       };
18996     }
18997   }
18998 }
18999
19000
19001 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
19002   char * jresult ;
19003   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
19004   Dali::Property::Index arg2 ;
19005   std::string *result = 0 ;
19006
19007   arg1 = (Dali::TypeInfo *)jarg1;
19008   arg2 = (Dali::Property::Index)jarg2;
19009   {
19010     try {
19011       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
19012     } catch (std::out_of_range& e) {
19013       {
19014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19015       };
19016     } catch (std::exception& e) {
19017       {
19018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19019       };
19020     } catch (...) {
19021       {
19022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19023       };
19024     }
19025   }
19026   jresult = SWIG_csharp_string_callback(result->c_str());
19027   return jresult;
19028 }
19029
19030
19031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
19032   void * jresult ;
19033   Dali::TypeRegistry result;
19034
19035   {
19036     try {
19037       result = Dali::TypeRegistry::Get();
19038     } catch (std::out_of_range& e) {
19039       {
19040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19041       };
19042     } catch (std::exception& e) {
19043       {
19044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19045       };
19046     } catch (...) {
19047       {
19048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19049       };
19050     }
19051   }
19052   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
19053   return jresult;
19054 }
19055
19056
19057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
19058   void * jresult ;
19059   Dali::TypeRegistry *result = 0 ;
19060
19061   {
19062     try {
19063       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
19064     } catch (std::out_of_range& e) {
19065       {
19066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19067       };
19068     } catch (std::exception& e) {
19069       {
19070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19071       };
19072     } catch (...) {
19073       {
19074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19075       };
19076     }
19077   }
19078   jresult = (void *)result;
19079   return jresult;
19080 }
19081
19082
19083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
19084   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19085
19086   arg1 = (Dali::TypeRegistry *)jarg1;
19087   {
19088     try {
19089       delete arg1;
19090     } catch (std::out_of_range& e) {
19091       {
19092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19093       };
19094     } catch (std::exception& e) {
19095       {
19096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19097       };
19098     } catch (...) {
19099       {
19100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19101       };
19102     }
19103   }
19104 }
19105
19106
19107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
19108   void * jresult ;
19109   Dali::TypeRegistry *arg1 = 0 ;
19110   Dali::TypeRegistry *result = 0 ;
19111
19112   arg1 = (Dali::TypeRegistry *)jarg1;
19113   if (!arg1) {
19114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19115     return 0;
19116   }
19117   {
19118     try {
19119       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
19120     } catch (std::out_of_range& e) {
19121       {
19122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19123       };
19124     } catch (std::exception& e) {
19125       {
19126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19127       };
19128     } catch (...) {
19129       {
19130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19131       };
19132     }
19133   }
19134   jresult = (void *)result;
19135   return jresult;
19136 }
19137
19138
19139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
19140   void * jresult ;
19141   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19142   Dali::TypeRegistry *arg2 = 0 ;
19143   Dali::TypeRegistry *result = 0 ;
19144
19145   arg1 = (Dali::TypeRegistry *)jarg1;
19146   arg2 = (Dali::TypeRegistry *)jarg2;
19147   if (!arg2) {
19148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19149     return 0;
19150   }
19151   {
19152     try {
19153       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
19154     } catch (std::out_of_range& e) {
19155       {
19156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19157       };
19158     } catch (std::exception& e) {
19159       {
19160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19161       };
19162     } catch (...) {
19163       {
19164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19165       };
19166     }
19167   }
19168   jresult = (void *)result;
19169   return jresult;
19170 }
19171
19172
19173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
19174   void * jresult ;
19175   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19176   std::string *arg2 = 0 ;
19177   Dali::TypeInfo result;
19178
19179   arg1 = (Dali::TypeRegistry *)jarg1;
19180   if (!jarg2) {
19181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19182     return 0;
19183   }
19184   std::string arg2_str(jarg2);
19185   arg2 = &arg2_str;
19186   {
19187     try {
19188       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
19189     } catch (std::out_of_range& e) {
19190       {
19191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19192       };
19193     } catch (std::exception& e) {
19194       {
19195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19196       };
19197     } catch (...) {
19198       {
19199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19200       };
19201     }
19202   }
19203   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19204
19205   //argout typemap for const std::string&
19206
19207   return jresult;
19208 }
19209
19210
19211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
19212   void * jresult ;
19213   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19214   std::type_info *arg2 = 0 ;
19215   Dali::TypeInfo result;
19216
19217   arg1 = (Dali::TypeRegistry *)jarg1;
19218   arg2 = (std::type_info *)jarg2;
19219   if (!arg2) {
19220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19221     return 0;
19222   }
19223   {
19224     try {
19225       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
19226     } catch (std::out_of_range& e) {
19227       {
19228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19229       };
19230     } catch (std::exception& e) {
19231       {
19232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19233       };
19234     } catch (...) {
19235       {
19236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19237       };
19238     }
19239   }
19240   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19241   return jresult;
19242 }
19243
19244
19245 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
19246   unsigned long jresult ;
19247   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19248   size_t result;
19249
19250   arg1 = (Dali::TypeRegistry *)jarg1;
19251   {
19252     try {
19253       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
19254     } catch (std::out_of_range& e) {
19255       {
19256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19257       };
19258     } catch (std::exception& e) {
19259       {
19260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19261       };
19262     } catch (...) {
19263       {
19264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19265       };
19266     }
19267   }
19268   jresult = (unsigned long)result;
19269   return jresult;
19270 }
19271
19272
19273 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
19274   char * jresult ;
19275   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19276   size_t arg2 ;
19277   std::string result;
19278
19279   arg1 = (Dali::TypeRegistry *)jarg1;
19280   arg2 = (size_t)jarg2;
19281   {
19282     try {
19283       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
19284     } catch (std::out_of_range& e) {
19285       {
19286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19287       };
19288     } catch (std::exception& e) {
19289       {
19290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19291       };
19292     } catch (...) {
19293       {
19294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19295       };
19296     }
19297   }
19298   jresult = SWIG_csharp_string_callback((&result)->c_str());
19299   return jresult;
19300 }
19301
19302
19303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_2(void * jarg1) {
19304   void * jresult ;
19305   Dali::Internal::TypeRegistry *arg1 = (Dali::Internal::TypeRegistry *) 0 ;
19306   Dali::TypeRegistry *result = 0 ;
19307
19308   arg1 = (Dali::Internal::TypeRegistry *)jarg1;
19309   {
19310     try {
19311       result = (Dali::TypeRegistry *)new Dali::TypeRegistry(arg1);
19312     } catch (std::out_of_range& e) {
19313       {
19314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19315       };
19316     } catch (std::exception& e) {
19317       {
19318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19319       };
19320     } catch (...) {
19321       {
19322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19323       };
19324     }
19325   }
19326   jresult = (void *)result;
19327   return jresult;
19328 }
19329
19330
19331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
19332   void * jresult ;
19333   std::type_info *arg1 = 0 ;
19334   std::type_info *arg2 = 0 ;
19335   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19336   Dali::TypeRegistration *result = 0 ;
19337
19338   arg1 = (std::type_info *)jarg1;
19339   if (!arg1) {
19340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19341     return 0;
19342   }
19343   arg2 = (std::type_info *)jarg2;
19344   if (!arg2) {
19345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19346     return 0;
19347   }
19348   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19349   {
19350     try {
19351       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
19352     } catch (std::out_of_range& e) {
19353       {
19354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19355       };
19356     } catch (std::exception& e) {
19357       {
19358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19359       };
19360     } catch (...) {
19361       {
19362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19363       };
19364     }
19365   }
19366   jresult = (void *)result;
19367   return jresult;
19368 }
19369
19370
19371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
19372   void * jresult ;
19373   std::type_info *arg1 = 0 ;
19374   std::type_info *arg2 = 0 ;
19375   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19376   bool arg4 ;
19377   Dali::TypeRegistration *result = 0 ;
19378
19379   arg1 = (std::type_info *)jarg1;
19380   if (!arg1) {
19381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19382     return 0;
19383   }
19384   arg2 = (std::type_info *)jarg2;
19385   if (!arg2) {
19386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19387     return 0;
19388   }
19389   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19390   arg4 = jarg4 ? true : false;
19391   {
19392     try {
19393       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
19394     } catch (std::out_of_range& e) {
19395       {
19396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19397       };
19398     } catch (std::exception& e) {
19399       {
19400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19401       };
19402     } catch (...) {
19403       {
19404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19405       };
19406     }
19407   }
19408   jresult = (void *)result;
19409   return jresult;
19410 }
19411
19412
19413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
19414   void * jresult ;
19415   std::string *arg1 = 0 ;
19416   std::type_info *arg2 = 0 ;
19417   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19418   Dali::TypeRegistration *result = 0 ;
19419
19420   if (!jarg1) {
19421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19422     return 0;
19423   }
19424   std::string arg1_str(jarg1);
19425   arg1 = &arg1_str;
19426   arg2 = (std::type_info *)jarg2;
19427   if (!arg2) {
19428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19429     return 0;
19430   }
19431   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19432   {
19433     try {
19434       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
19435     } catch (std::out_of_range& e) {
19436       {
19437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19438       };
19439     } catch (std::exception& e) {
19440       {
19441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19442       };
19443     } catch (...) {
19444       {
19445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19446       };
19447     }
19448   }
19449   jresult = (void *)result;
19450
19451   //argout typemap for const std::string&
19452
19453   return jresult;
19454 }
19455
19456
19457 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
19458   char * jresult ;
19459   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19460   std::string result;
19461
19462   arg1 = (Dali::TypeRegistration *)jarg1;
19463   {
19464     try {
19465       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
19466     } catch (std::out_of_range& e) {
19467       {
19468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19469       };
19470     } catch (std::exception& e) {
19471       {
19472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19473       };
19474     } catch (...) {
19475       {
19476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19477       };
19478     }
19479   }
19480   jresult = SWIG_csharp_string_callback((&result)->c_str());
19481   return jresult;
19482 }
19483
19484
19485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
19486   std::string *arg1 = 0 ;
19487   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
19488
19489   if (!jarg1) {
19490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19491     return ;
19492   }
19493   std::string arg1_str(jarg1);
19494   arg1 = &arg1_str;
19495   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
19496   {
19497     try {
19498       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
19499     } catch (std::out_of_range& e) {
19500       {
19501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19502       };
19503     } catch (std::exception& e) {
19504       {
19505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19506       };
19507     } catch (...) {
19508       {
19509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19510       };
19511     }
19512   }
19513
19514   //argout typemap for const std::string&
19515
19516 }
19517
19518
19519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19520   std::string *arg1 = 0 ;
19521   std::string *arg2 = 0 ;
19522   int arg3 ;
19523   Dali::Property::Type arg4 ;
19524   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
19525   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
19526
19527   if (!jarg1) {
19528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19529     return ;
19530   }
19531   std::string arg1_str(jarg1);
19532   arg1 = &arg1_str;
19533   if (!jarg2) {
19534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19535     return ;
19536   }
19537   std::string arg2_str(jarg2);
19538   arg2 = &arg2_str;
19539   arg3 = (int)jarg3;
19540   arg4 = (Dali::Property::Type)jarg4;
19541   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
19542   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
19543   {
19544     try {
19545       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19546     } catch (std::out_of_range& e) {
19547       {
19548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19549       };
19550     } catch (std::exception& e) {
19551       {
19552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19553       };
19554     } catch (...) {
19555       {
19556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19557       };
19558     }
19559   }
19560
19561   //argout typemap for const std::string&
19562
19563
19564   //argout typemap for const std::string&
19565
19566 }
19567
19568
19569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
19570   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19571
19572   arg1 = (Dali::TypeRegistration *)jarg1;
19573   {
19574     try {
19575       delete arg1;
19576     } catch (std::out_of_range& e) {
19577       {
19578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19579       };
19580     } catch (std::exception& e) {
19581       {
19582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19583       };
19584     } catch (...) {
19585       {
19586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19587       };
19588     }
19589   }
19590 }
19591
19592
19593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
19594   void * jresult ;
19595   Dali::TypeRegistration *arg1 = 0 ;
19596   std::string *arg2 = 0 ;
19597   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
19598   Dali::SignalConnectorType *result = 0 ;
19599
19600   arg1 = (Dali::TypeRegistration *)jarg1;
19601   if (!arg1) {
19602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19603     return 0;
19604   }
19605   if (!jarg2) {
19606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19607     return 0;
19608   }
19609   std::string arg2_str(jarg2);
19610   arg2 = &arg2_str;
19611   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
19612   {
19613     try {
19614       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
19615     } catch (std::out_of_range& e) {
19616       {
19617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19618       };
19619     } catch (std::exception& e) {
19620       {
19621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19622       };
19623     } catch (...) {
19624       {
19625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19626       };
19627     }
19628   }
19629   jresult = (void *)result;
19630
19631   //argout typemap for const std::string&
19632
19633   return jresult;
19634 }
19635
19636
19637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
19638   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
19639
19640   arg1 = (Dali::SignalConnectorType *)jarg1;
19641   {
19642     try {
19643       delete arg1;
19644     } catch (std::out_of_range& e) {
19645       {
19646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19647       };
19648     } catch (std::exception& e) {
19649       {
19650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19651       };
19652     } catch (...) {
19653       {
19654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19655       };
19656     }
19657   }
19658 }
19659
19660
19661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
19662   void * jresult ;
19663   Dali::TypeRegistration *arg1 = 0 ;
19664   std::string *arg2 = 0 ;
19665   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
19666   Dali::TypeAction *result = 0 ;
19667
19668   arg1 = (Dali::TypeRegistration *)jarg1;
19669   if (!arg1) {
19670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19671     return 0;
19672   }
19673   if (!jarg2) {
19674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19675     return 0;
19676   }
19677   std::string arg2_str(jarg2);
19678   arg2 = &arg2_str;
19679   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
19680   {
19681     try {
19682       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
19683     } catch (std::out_of_range& e) {
19684       {
19685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19686       };
19687     } catch (std::exception& e) {
19688       {
19689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19690       };
19691     } catch (...) {
19692       {
19693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19694       };
19695     }
19696   }
19697   jresult = (void *)result;
19698
19699   //argout typemap for const std::string&
19700
19701   return jresult;
19702 }
19703
19704
19705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
19706   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
19707
19708   arg1 = (Dali::TypeAction *)jarg1;
19709   {
19710     try {
19711       delete arg1;
19712     } catch (std::out_of_range& e) {
19713       {
19714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19715       };
19716     } catch (std::exception& e) {
19717       {
19718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19719       };
19720     } catch (...) {
19721       {
19722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19723       };
19724     }
19725   }
19726 }
19727
19728
19729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19730   void * jresult ;
19731   Dali::TypeRegistration *arg1 = 0 ;
19732   std::string *arg2 = 0 ;
19733   Dali::Property::Index arg3 ;
19734   Dali::Property::Type arg4 ;
19735   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
19736   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
19737   Dali::PropertyRegistration *result = 0 ;
19738
19739   arg1 = (Dali::TypeRegistration *)jarg1;
19740   if (!arg1) {
19741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19742     return 0;
19743   }
19744   if (!jarg2) {
19745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19746     return 0;
19747   }
19748   std::string arg2_str(jarg2);
19749   arg2 = &arg2_str;
19750   arg3 = (Dali::Property::Index)jarg3;
19751   arg4 = (Dali::Property::Type)jarg4;
19752   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
19753   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
19754   {
19755     try {
19756       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19757     } catch (std::out_of_range& e) {
19758       {
19759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19760       };
19761     } catch (std::exception& e) {
19762       {
19763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19764       };
19765     } catch (...) {
19766       {
19767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19768       };
19769     }
19770   }
19771   jresult = (void *)result;
19772
19773   //argout typemap for const std::string&
19774
19775   return jresult;
19776 }
19777
19778
19779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
19780   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
19781
19782   arg1 = (Dali::PropertyRegistration *)jarg1;
19783   {
19784     try {
19785       delete arg1;
19786     } catch (std::out_of_range& e) {
19787       {
19788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19789       };
19790     } catch (std::exception& e) {
19791       {
19792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19793       };
19794     } catch (...) {
19795       {
19796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19797       };
19798     }
19799   }
19800 }
19801
19802
19803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19804   void * jresult ;
19805   Dali::TypeRegistration *arg1 = 0 ;
19806   std::string *arg2 = 0 ;
19807   Dali::Property::Index arg3 ;
19808   Dali::Property::Type arg4 ;
19809   Dali::AnimatablePropertyRegistration *result = 0 ;
19810
19811   arg1 = (Dali::TypeRegistration *)jarg1;
19812   if (!arg1) {
19813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19814     return 0;
19815   }
19816   if (!jarg2) {
19817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19818     return 0;
19819   }
19820   std::string arg2_str(jarg2);
19821   arg2 = &arg2_str;
19822   arg3 = (Dali::Property::Index)jarg3;
19823   arg4 = (Dali::Property::Type)jarg4;
19824   {
19825     try {
19826       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19827     } catch (std::out_of_range& e) {
19828       {
19829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19830       };
19831     } catch (std::exception& e) {
19832       {
19833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19834       };
19835     } catch (...) {
19836       {
19837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19838       };
19839     }
19840   }
19841   jresult = (void *)result;
19842
19843   //argout typemap for const std::string&
19844
19845   return jresult;
19846 }
19847
19848
19849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
19850   void * jresult ;
19851   Dali::TypeRegistration *arg1 = 0 ;
19852   std::string *arg2 = 0 ;
19853   Dali::Property::Index arg3 ;
19854   Dali::Property::Value *arg4 = 0 ;
19855   Dali::AnimatablePropertyRegistration *result = 0 ;
19856
19857   arg1 = (Dali::TypeRegistration *)jarg1;
19858   if (!arg1) {
19859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19860     return 0;
19861   }
19862   if (!jarg2) {
19863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19864     return 0;
19865   }
19866   std::string arg2_str(jarg2);
19867   arg2 = &arg2_str;
19868   arg3 = (Dali::Property::Index)jarg3;
19869   arg4 = (Dali::Property::Value *)jarg4;
19870   if (!arg4) {
19871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
19872     return 0;
19873   }
19874   {
19875     try {
19876       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
19877     } catch (std::out_of_range& e) {
19878       {
19879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19880       };
19881     } catch (std::exception& e) {
19882       {
19883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19884       };
19885     } catch (...) {
19886       {
19887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19888       };
19889     }
19890   }
19891   jresult = (void *)result;
19892
19893   //argout typemap for const std::string&
19894
19895   return jresult;
19896 }
19897
19898
19899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
19900   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
19901
19902   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
19903   {
19904     try {
19905       delete arg1;
19906     } catch (std::out_of_range& e) {
19907       {
19908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19909       };
19910     } catch (std::exception& e) {
19911       {
19912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19913       };
19914     } catch (...) {
19915       {
19916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19917       };
19918     }
19919   }
19920 }
19921
19922
19923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
19924   void * jresult ;
19925   Dali::TypeRegistration *arg1 = 0 ;
19926   std::string *arg2 = 0 ;
19927   Dali::Property::Index arg3 ;
19928   Dali::Property::Index arg4 ;
19929   unsigned int arg5 ;
19930   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
19931
19932   arg1 = (Dali::TypeRegistration *)jarg1;
19933   if (!arg1) {
19934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19935     return 0;
19936   }
19937   if (!jarg2) {
19938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19939     return 0;
19940   }
19941   std::string arg2_str(jarg2);
19942   arg2 = &arg2_str;
19943   arg3 = (Dali::Property::Index)jarg3;
19944   arg4 = (Dali::Property::Index)jarg4;
19945   arg5 = (unsigned int)jarg5;
19946   {
19947     try {
19948       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
19949     } catch (std::out_of_range& e) {
19950       {
19951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19952       };
19953     } catch (std::exception& e) {
19954       {
19955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19956       };
19957     } catch (...) {
19958       {
19959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19960       };
19961     }
19962   }
19963   jresult = (void *)result;
19964
19965   //argout typemap for const std::string&
19966
19967   return jresult;
19968 }
19969
19970
19971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
19972   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
19973
19974   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
19975   {
19976     try {
19977       delete arg1;
19978     } catch (std::out_of_range& e) {
19979       {
19980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19981       };
19982     } catch (std::exception& e) {
19983       {
19984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19985       };
19986     } catch (...) {
19987       {
19988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19989       };
19990     }
19991   }
19992 }
19993
19994
19995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19996   void * jresult ;
19997   Dali::TypeRegistration *arg1 = 0 ;
19998   std::string *arg2 = 0 ;
19999   Dali::Property::Index arg3 ;
20000   Dali::Property::Type arg4 ;
20001   Dali::ChildPropertyRegistration *result = 0 ;
20002
20003   arg1 = (Dali::TypeRegistration *)jarg1;
20004   if (!arg1) {
20005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
20006     return 0;
20007   }
20008   if (!jarg2) {
20009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20010     return 0;
20011   }
20012   std::string arg2_str(jarg2);
20013   arg2 = &arg2_str;
20014   arg3 = (Dali::Property::Index)jarg3;
20015   arg4 = (Dali::Property::Type)jarg4;
20016   {
20017     try {
20018       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
20019     } catch (std::out_of_range& e) {
20020       {
20021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20022       };
20023     } catch (std::exception& e) {
20024       {
20025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20026       };
20027     } catch (...) {
20028       {
20029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20030       };
20031     }
20032   }
20033   jresult = (void *)result;
20034
20035   //argout typemap for const std::string&
20036
20037   return jresult;
20038 }
20039
20040
20041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
20042   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
20043
20044   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
20045   {
20046     try {
20047       delete arg1;
20048     } catch (std::out_of_range& e) {
20049       {
20050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20051       };
20052     } catch (std::exception& e) {
20053       {
20054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20055       };
20056     } catch (...) {
20057       {
20058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20059       };
20060     }
20061   }
20062 }
20063
20064
20065 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
20066   unsigned int jresult ;
20067   std::string *arg1 = 0 ;
20068   std::type_info *arg2 = 0 ;
20069   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
20070   bool result;
20071
20072   if (!jarg1) {
20073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20074     return 0;
20075   }
20076   std::string arg1_str(jarg1);
20077   arg1 = &arg1_str;
20078   arg2 = (std::type_info *)jarg2;
20079   if (!arg2) {
20080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
20081     return 0;
20082   }
20083   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
20084   {
20085     try {
20086       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
20087     } catch (std::out_of_range& e) {
20088       {
20089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20090       };
20091     } catch (std::exception& e) {
20092       {
20093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20094       };
20095     } catch (...) {
20096       {
20097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20098       };
20099     }
20100   }
20101   jresult = result;
20102
20103   //argout typemap for const std::string&
20104
20105   return jresult;
20106 }
20107
20108
20109 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
20110   unsigned int jresult ;
20111   std::string *arg1 = 0 ;
20112   std::string *arg2 = 0 ;
20113   Dali::Property::Index arg3 ;
20114   Dali::Property::Type arg4 ;
20115   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
20116   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
20117   bool result;
20118
20119   if (!jarg1) {
20120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20121     return 0;
20122   }
20123   std::string arg1_str(jarg1);
20124   arg1 = &arg1_str;
20125   if (!jarg2) {
20126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20127     return 0;
20128   }
20129   std::string arg2_str(jarg2);
20130   arg2 = &arg2_str;
20131   arg3 = (Dali::Property::Index)jarg3;
20132   arg4 = (Dali::Property::Type)jarg4;
20133   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
20134   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
20135   {
20136     try {
20137       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
20138     } catch (std::out_of_range& e) {
20139       {
20140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20141       };
20142     } catch (std::exception& e) {
20143       {
20144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20145       };
20146     } catch (...) {
20147       {
20148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20149       };
20150     }
20151   }
20152   jresult = result;
20153
20154   //argout typemap for const std::string&
20155
20156
20157   //argout typemap for const std::string&
20158
20159   return jresult;
20160 }
20161
20162
20163 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
20164   float jresult ;
20165   float result;
20166
20167   result = (float)(float)Dali::ParentOrigin::TOP;
20168   jresult = result;
20169   return jresult;
20170 }
20171
20172
20173 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
20174   float jresult ;
20175   float result;
20176
20177   result = (float)(float)Dali::ParentOrigin::BOTTOM;
20178   jresult = result;
20179   return jresult;
20180 }
20181
20182
20183 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
20184   float jresult ;
20185   float result;
20186
20187   result = (float)(float)Dali::ParentOrigin::LEFT;
20188   jresult = result;
20189   return jresult;
20190 }
20191
20192
20193 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
20194   float jresult ;
20195   float result;
20196
20197   result = (float)(float)Dali::ParentOrigin::RIGHT;
20198   jresult = result;
20199   return jresult;
20200 }
20201
20202
20203 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
20204   float jresult ;
20205   float result;
20206
20207   result = (float)(float)Dali::ParentOrigin::MIDDLE;
20208   jresult = result;
20209   return jresult;
20210 }
20211
20212
20213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
20214   void * jresult ;
20215   Dali::Vector3 *result = 0 ;
20216
20217   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
20218   jresult = (void *)result;
20219   return jresult;
20220 }
20221
20222
20223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
20224   void * jresult ;
20225   Dali::Vector3 *result = 0 ;
20226
20227   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
20228   jresult = (void *)result;
20229   return jresult;
20230 }
20231
20232
20233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
20234   void * jresult ;
20235   Dali::Vector3 *result = 0 ;
20236
20237   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
20238   jresult = (void *)result;
20239   return jresult;
20240 }
20241
20242
20243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
20244   void * jresult ;
20245   Dali::Vector3 *result = 0 ;
20246
20247   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
20248   jresult = (void *)result;
20249   return jresult;
20250 }
20251
20252
20253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
20254   void * jresult ;
20255   Dali::Vector3 *result = 0 ;
20256
20257   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
20258   jresult = (void *)result;
20259   return jresult;
20260 }
20261
20262
20263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
20264   void * jresult ;
20265   Dali::Vector3 *result = 0 ;
20266
20267   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
20268   jresult = (void *)result;
20269   return jresult;
20270 }
20271
20272
20273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
20274   void * jresult ;
20275   Dali::Vector3 *result = 0 ;
20276
20277   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
20278   jresult = (void *)result;
20279   return jresult;
20280 }
20281
20282
20283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
20284   void * jresult ;
20285   Dali::Vector3 *result = 0 ;
20286
20287   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
20288   jresult = (void *)result;
20289   return jresult;
20290 }
20291
20292
20293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
20294   void * jresult ;
20295   Dali::Vector3 *result = 0 ;
20296
20297   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
20298   jresult = (void *)result;
20299   return jresult;
20300 }
20301
20302
20303 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
20304   float jresult ;
20305   float result;
20306
20307   result = (float)(float)Dali::AnchorPoint::TOP;
20308   jresult = result;
20309   return jresult;
20310 }
20311
20312
20313 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
20314   float jresult ;
20315   float result;
20316
20317   result = (float)(float)Dali::AnchorPoint::BOTTOM;
20318   jresult = result;
20319   return jresult;
20320 }
20321
20322
20323 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
20324   float jresult ;
20325   float result;
20326
20327   result = (float)(float)Dali::AnchorPoint::LEFT;
20328   jresult = result;
20329   return jresult;
20330 }
20331
20332
20333 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
20334   float jresult ;
20335   float result;
20336
20337   result = (float)(float)Dali::AnchorPoint::RIGHT;
20338   jresult = result;
20339   return jresult;
20340 }
20341
20342
20343 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
20344   float jresult ;
20345   float result;
20346
20347   result = (float)(float)Dali::AnchorPoint::MIDDLE;
20348   jresult = result;
20349   return jresult;
20350 }
20351
20352
20353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
20354   void * jresult ;
20355   Dali::Vector3 *result = 0 ;
20356
20357   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
20358   jresult = (void *)result;
20359   return jresult;
20360 }
20361
20362
20363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
20364   void * jresult ;
20365   Dali::Vector3 *result = 0 ;
20366
20367   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
20368   jresult = (void *)result;
20369   return jresult;
20370 }
20371
20372
20373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
20374   void * jresult ;
20375   Dali::Vector3 *result = 0 ;
20376
20377   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
20378   jresult = (void *)result;
20379   return jresult;
20380 }
20381
20382
20383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
20384   void * jresult ;
20385   Dali::Vector3 *result = 0 ;
20386
20387   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
20388   jresult = (void *)result;
20389   return jresult;
20390 }
20391
20392
20393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
20394   void * jresult ;
20395   Dali::Vector3 *result = 0 ;
20396
20397   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
20398   jresult = (void *)result;
20399   return jresult;
20400 }
20401
20402
20403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
20404   void * jresult ;
20405   Dali::Vector3 *result = 0 ;
20406
20407   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
20408   jresult = (void *)result;
20409   return jresult;
20410 }
20411
20412
20413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
20414   void * jresult ;
20415   Dali::Vector3 *result = 0 ;
20416
20417   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
20418   jresult = (void *)result;
20419   return jresult;
20420 }
20421
20422
20423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
20424   void * jresult ;
20425   Dali::Vector3 *result = 0 ;
20426
20427   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
20428   jresult = (void *)result;
20429   return jresult;
20430 }
20431
20432
20433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
20434   void * jresult ;
20435   Dali::Vector3 *result = 0 ;
20436
20437   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
20438   jresult = (void *)result;
20439   return jresult;
20440 }
20441
20442
20443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
20444   void * jresult ;
20445   Dali::Vector4 *result = 0 ;
20446
20447   result = (Dali::Vector4 *)&Dali::Color::BLACK;
20448   jresult = (void *)result;
20449   return jresult;
20450 }
20451
20452
20453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
20454   void * jresult ;
20455   Dali::Vector4 *result = 0 ;
20456
20457   result = (Dali::Vector4 *)&Dali::Color::WHITE;
20458   jresult = (void *)result;
20459   return jresult;
20460 }
20461
20462
20463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
20464   void * jresult ;
20465   Dali::Vector4 *result = 0 ;
20466
20467   result = (Dali::Vector4 *)&Dali::Color::RED;
20468   jresult = (void *)result;
20469   return jresult;
20470 }
20471
20472
20473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
20474   void * jresult ;
20475   Dali::Vector4 *result = 0 ;
20476
20477   result = (Dali::Vector4 *)&Dali::Color::GREEN;
20478   jresult = (void *)result;
20479   return jresult;
20480 }
20481
20482
20483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
20484   void * jresult ;
20485   Dali::Vector4 *result = 0 ;
20486
20487   result = (Dali::Vector4 *)&Dali::Color::BLUE;
20488   jresult = (void *)result;
20489   return jresult;
20490 }
20491
20492
20493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
20494   void * jresult ;
20495   Dali::Vector4 *result = 0 ;
20496
20497   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
20498   jresult = (void *)result;
20499   return jresult;
20500 }
20501
20502
20503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
20504   void * jresult ;
20505   Dali::Vector4 *result = 0 ;
20506
20507   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
20508   jresult = (void *)result;
20509   return jresult;
20510 }
20511
20512
20513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
20514   void * jresult ;
20515   Dali::Vector4 *result = 0 ;
20516
20517   result = (Dali::Vector4 *)&Dali::Color::CYAN;
20518   jresult = (void *)result;
20519   return jresult;
20520 }
20521
20522
20523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
20524   void * jresult ;
20525   Dali::Vector4 *result = 0 ;
20526
20527   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
20528   jresult = (void *)result;
20529   return jresult;
20530 }
20531
20532
20533 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
20534   float jresult ;
20535   float result;
20536
20537   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
20538   jresult = result;
20539   return jresult;
20540 }
20541
20542
20543 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
20544   float jresult ;
20545   float result;
20546
20547   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
20548   jresult = result;
20549   return jresult;
20550 }
20551
20552
20553 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
20554   float jresult ;
20555   float result;
20556
20557   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
20558   jresult = result;
20559   return jresult;
20560 }
20561
20562
20563 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
20564   float jresult ;
20565   float result;
20566
20567   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
20568   jresult = result;
20569   return jresult;
20570 }
20571
20572
20573 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
20574   float jresult ;
20575   float result;
20576
20577   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
20578   jresult = result;
20579   return jresult;
20580 }
20581
20582
20583 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
20584   float jresult ;
20585   float result;
20586
20587   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
20588   jresult = result;
20589   return jresult;
20590 }
20591
20592
20593 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
20594   float jresult ;
20595   float result;
20596
20597   result = (float)(float)Dali::Math::PI;
20598   jresult = result;
20599   return jresult;
20600 }
20601
20602
20603 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
20604   float jresult ;
20605   float result;
20606
20607   result = (float)(float)Dali::Math::PI_2;
20608   jresult = result;
20609   return jresult;
20610 }
20611
20612
20613 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
20614   float jresult ;
20615   float result;
20616
20617   result = (float)(float)Dali::Math::PI_4;
20618   jresult = result;
20619   return jresult;
20620 }
20621
20622
20623 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
20624   float jresult ;
20625   float result;
20626
20627   result = (float)(float)Dali::Math::PI_OVER_180;
20628   jresult = result;
20629   return jresult;
20630 }
20631
20632
20633 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
20634   float jresult ;
20635   float result;
20636
20637   result = (float)(float)Dali::Math::ONE80_OVER_PI;
20638   jresult = result;
20639   return jresult;
20640 }
20641
20642
20643 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
20644   int jresult ;
20645   Dali::ResizePolicy::Type result;
20646
20647   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
20648   jresult = (int)result;
20649   return jresult;
20650 }
20651
20652
20653 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
20654   unsigned long jresult ;
20655   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20656   Dali::VectorBase::SizeType result;
20657
20658   arg1 = (Dali::VectorBase *)jarg1;
20659   {
20660     try {
20661       result = ((Dali::VectorBase const *)arg1)->Count();
20662     } catch (std::out_of_range& e) {
20663       {
20664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20665       };
20666     } catch (std::exception& e) {
20667       {
20668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20669       };
20670     } catch (...) {
20671       {
20672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20673       };
20674     }
20675   }
20676   jresult = (unsigned long)result;
20677   return jresult;
20678 }
20679
20680
20681 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
20682   unsigned long jresult ;
20683   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20684   Dali::VectorBase::SizeType result;
20685
20686   arg1 = (Dali::VectorBase *)jarg1;
20687   {
20688     try {
20689       result = ((Dali::VectorBase const *)arg1)->Size();
20690     } catch (std::out_of_range& e) {
20691       {
20692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20693       };
20694     } catch (std::exception& e) {
20695       {
20696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20697       };
20698     } catch (...) {
20699       {
20700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20701       };
20702     }
20703   }
20704   jresult = (unsigned long)result;
20705   return jresult;
20706 }
20707
20708
20709 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
20710   unsigned int jresult ;
20711   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20712   bool result;
20713
20714   arg1 = (Dali::VectorBase *)jarg1;
20715   {
20716     try {
20717       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
20718     } catch (std::out_of_range& e) {
20719       {
20720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20721       };
20722     } catch (std::exception& e) {
20723       {
20724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20725       };
20726     } catch (...) {
20727       {
20728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20729       };
20730     }
20731   }
20732   jresult = result;
20733   return jresult;
20734 }
20735
20736
20737 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
20738   unsigned long jresult ;
20739   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20740   Dali::VectorBase::SizeType result;
20741
20742   arg1 = (Dali::VectorBase *)jarg1;
20743   {
20744     try {
20745       result = ((Dali::VectorBase const *)arg1)->Capacity();
20746     } catch (std::out_of_range& e) {
20747       {
20748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20749       };
20750     } catch (std::exception& e) {
20751       {
20752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20753       };
20754     } catch (...) {
20755       {
20756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20757       };
20758     }
20759   }
20760   jresult = (unsigned long)result;
20761   return jresult;
20762 }
20763
20764
20765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
20766   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20767
20768   arg1 = (Dali::VectorBase *)jarg1;
20769   {
20770     try {
20771       (arg1)->Release();
20772     } catch (std::out_of_range& e) {
20773       {
20774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20775       };
20776     } catch (std::exception& e) {
20777       {
20778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20779       };
20780     } catch (...) {
20781       {
20782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20783       };
20784     }
20785   }
20786 }
20787
20788
20789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
20790   void * jresult ;
20791   Dali::Image *result = 0 ;
20792
20793   {
20794     try {
20795       result = (Dali::Image *)new Dali::Image();
20796     } catch (std::out_of_range& e) {
20797       {
20798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20799       };
20800     } catch (std::exception& e) {
20801       {
20802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20803       };
20804     } catch (...) {
20805       {
20806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20807       };
20808     }
20809   }
20810   jresult = (void *)result;
20811   return jresult;
20812 }
20813
20814
20815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
20816   Dali::Image *arg1 = (Dali::Image *) 0 ;
20817
20818   arg1 = (Dali::Image *)jarg1;
20819   {
20820     try {
20821       delete arg1;
20822     } catch (std::out_of_range& e) {
20823       {
20824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20825       };
20826     } catch (std::exception& e) {
20827       {
20828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20829       };
20830     } catch (...) {
20831       {
20832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20833       };
20834     }
20835   }
20836 }
20837
20838
20839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
20840   void * jresult ;
20841   Dali::Image *arg1 = 0 ;
20842   Dali::Image *result = 0 ;
20843
20844   arg1 = (Dali::Image *)jarg1;
20845   if (!arg1) {
20846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20847     return 0;
20848   }
20849   {
20850     try {
20851       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
20852     } catch (std::out_of_range& e) {
20853       {
20854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20855       };
20856     } catch (std::exception& e) {
20857       {
20858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20859       };
20860     } catch (...) {
20861       {
20862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20863       };
20864     }
20865   }
20866   jresult = (void *)result;
20867   return jresult;
20868 }
20869
20870
20871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
20872   void * jresult ;
20873   Dali::Image *arg1 = (Dali::Image *) 0 ;
20874   Dali::Image *arg2 = 0 ;
20875   Dali::Image *result = 0 ;
20876
20877   arg1 = (Dali::Image *)jarg1;
20878   arg2 = (Dali::Image *)jarg2;
20879   if (!arg2) {
20880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20881     return 0;
20882   }
20883   {
20884     try {
20885       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
20886     } catch (std::out_of_range& e) {
20887       {
20888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20889       };
20890     } catch (std::exception& e) {
20891       {
20892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20893       };
20894     } catch (...) {
20895       {
20896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20897       };
20898     }
20899   }
20900   jresult = (void *)result;
20901   return jresult;
20902 }
20903
20904
20905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
20906   void * jresult ;
20907   Dali::BaseHandle arg1 ;
20908   Dali::BaseHandle *argp1 ;
20909   Dali::Image result;
20910
20911   argp1 = (Dali::BaseHandle *)jarg1;
20912   if (!argp1) {
20913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20914     return 0;
20915   }
20916   arg1 = *argp1;
20917   {
20918     try {
20919       result = Dali::Image::DownCast(arg1);
20920     } catch (std::out_of_range& e) {
20921       {
20922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20923       };
20924     } catch (std::exception& e) {
20925       {
20926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20927       };
20928     } catch (...) {
20929       {
20930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20931       };
20932     }
20933   }
20934   jresult = new Dali::Image((const Dali::Image &)result);
20935   return jresult;
20936 }
20937
20938
20939 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
20940   unsigned int jresult ;
20941   Dali::Image *arg1 = (Dali::Image *) 0 ;
20942   unsigned int result;
20943
20944   arg1 = (Dali::Image *)jarg1;
20945   {
20946     try {
20947       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
20948     } catch (std::out_of_range& e) {
20949       {
20950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20951       };
20952     } catch (std::exception& e) {
20953       {
20954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20955       };
20956     } catch (...) {
20957       {
20958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20959       };
20960     }
20961   }
20962   jresult = result;
20963   return jresult;
20964 }
20965
20966
20967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
20968   unsigned int jresult ;
20969   Dali::Image *arg1 = (Dali::Image *) 0 ;
20970   unsigned int result;
20971
20972   arg1 = (Dali::Image *)jarg1;
20973   {
20974     try {
20975       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
20976     } catch (std::out_of_range& e) {
20977       {
20978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20979       };
20980     } catch (std::exception& e) {
20981       {
20982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20983       };
20984     } catch (...) {
20985       {
20986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20987       };
20988     }
20989   }
20990   jresult = result;
20991   return jresult;
20992 }
20993
20994
20995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
20996   void * jresult ;
20997   Dali::Image *arg1 = (Dali::Image *) 0 ;
20998   Dali::Image::ImageSignalType *result = 0 ;
20999
21000   arg1 = (Dali::Image *)jarg1;
21001   {
21002     try {
21003       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
21004     } catch (std::out_of_range& e) {
21005       {
21006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21007       };
21008     } catch (std::exception& e) {
21009       {
21010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21011       };
21012     } catch (...) {
21013       {
21014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21015       };
21016     }
21017   }
21018   jresult = (void *)result;
21019   return jresult;
21020 }
21021
21022
21023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
21024   int jresult ;
21025   Dali::Pixel::Format result;
21026
21027   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
21028   jresult = (int)result;
21029   return jresult;
21030 }
21031
21032
21033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
21034   int jresult ;
21035   Dali::Pixel::Format result;
21036
21037   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
21038   jresult = (int)result;
21039   return jresult;
21040 }
21041
21042
21043 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
21044   unsigned int jresult ;
21045   Dali::Pixel::Format arg1 ;
21046   bool result;
21047
21048   arg1 = (Dali::Pixel::Format)jarg1;
21049   {
21050     try {
21051       result = (bool)Dali::Pixel::HasAlpha(arg1);
21052     } catch (std::out_of_range& e) {
21053       {
21054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21055       };
21056     } catch (std::exception& e) {
21057       {
21058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21059       };
21060     } catch (...) {
21061       {
21062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21063       };
21064     }
21065   }
21066   jresult = result;
21067   return jresult;
21068 }
21069
21070
21071 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
21072   unsigned int jresult ;
21073   Dali::Pixel::Format arg1 ;
21074   unsigned int result;
21075
21076   arg1 = (Dali::Pixel::Format)jarg1;
21077   {
21078     try {
21079       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
21080     } catch (std::out_of_range& e) {
21081       {
21082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21083       };
21084     } catch (std::exception& e) {
21085       {
21086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21087       };
21088     } catch (...) {
21089       {
21090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21091       };
21092     }
21093   }
21094   jresult = result;
21095   return jresult;
21096 }
21097
21098
21099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
21100   Dali::Pixel::Format arg1 ;
21101   int *arg2 = 0 ;
21102   int *arg3 = 0 ;
21103
21104   arg1 = (Dali::Pixel::Format)jarg1;
21105   arg2 = (int *)jarg2;
21106   if (!arg2) {
21107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21108     return ;
21109   }
21110   arg3 = (int *)jarg3;
21111   if (!arg3) {
21112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21113     return ;
21114   }
21115   {
21116     try {
21117       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
21118     } catch (std::out_of_range& e) {
21119       {
21120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21121       };
21122     } catch (std::exception& e) {
21123       {
21124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21125       };
21126     } catch (...) {
21127       {
21128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21129       };
21130     }
21131   }
21132 }
21133
21134
21135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
21136   void * jresult ;
21137   unsigned char *arg1 = (unsigned char *) 0 ;
21138   unsigned int arg2 ;
21139   unsigned int arg3 ;
21140   unsigned int arg4 ;
21141   Dali::Pixel::Format arg5 ;
21142   Dali::PixelData::ReleaseFunction arg6 ;
21143   Dali::PixelData result;
21144
21145   arg1 = jarg1;
21146   arg2 = (unsigned int)jarg2;
21147   arg3 = (unsigned int)jarg3;
21148   arg4 = (unsigned int)jarg4;
21149   arg5 = (Dali::Pixel::Format)jarg5;
21150   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
21151   {
21152     try {
21153       result = Dali::PixelData::New(arg1,arg2,arg3,arg4,arg5,arg6);
21154     } catch (std::out_of_range& e) {
21155       {
21156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21157       };
21158     } catch (std::exception& e) {
21159       {
21160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21161       };
21162     } catch (...) {
21163       {
21164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21165       };
21166     }
21167   }
21168   jresult = new Dali::PixelData((const Dali::PixelData &)result);
21169
21170
21171   return jresult;
21172 }
21173
21174
21175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
21176   void * jresult ;
21177   Dali::PixelData *result = 0 ;
21178
21179   {
21180     try {
21181       result = (Dali::PixelData *)new Dali::PixelData();
21182     } catch (std::out_of_range& e) {
21183       {
21184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21185       };
21186     } catch (std::exception& e) {
21187       {
21188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21189       };
21190     } catch (...) {
21191       {
21192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21193       };
21194     }
21195   }
21196   jresult = (void *)result;
21197   return jresult;
21198 }
21199
21200
21201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
21202   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21203
21204   arg1 = (Dali::PixelData *)jarg1;
21205   {
21206     try {
21207       delete arg1;
21208     } catch (std::out_of_range& e) {
21209       {
21210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21211       };
21212     } catch (std::exception& e) {
21213       {
21214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21215       };
21216     } catch (...) {
21217       {
21218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21219       };
21220     }
21221   }
21222 }
21223
21224
21225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
21226   void * jresult ;
21227   Dali::PixelData *arg1 = 0 ;
21228   Dali::PixelData *result = 0 ;
21229
21230   arg1 = (Dali::PixelData *)jarg1;
21231   if (!arg1) {
21232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21233     return 0;
21234   }
21235   {
21236     try {
21237       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
21238     } catch (std::out_of_range& e) {
21239       {
21240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21241       };
21242     } catch (std::exception& e) {
21243       {
21244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21245       };
21246     } catch (...) {
21247       {
21248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21249       };
21250     }
21251   }
21252   jresult = (void *)result;
21253   return jresult;
21254 }
21255
21256
21257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
21258   void * jresult ;
21259   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21260   Dali::PixelData *arg2 = 0 ;
21261   Dali::PixelData *result = 0 ;
21262
21263   arg1 = (Dali::PixelData *)jarg1;
21264   arg2 = (Dali::PixelData *)jarg2;
21265   if (!arg2) {
21266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21267     return 0;
21268   }
21269   {
21270     try {
21271       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
21272     } catch (std::out_of_range& e) {
21273       {
21274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21275       };
21276     } catch (std::exception& e) {
21277       {
21278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21279       };
21280     } catch (...) {
21281       {
21282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21283       };
21284     }
21285   }
21286   jresult = (void *)result;
21287   return jresult;
21288 }
21289
21290
21291 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
21292   unsigned int jresult ;
21293   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21294   unsigned int result;
21295
21296   arg1 = (Dali::PixelData *)jarg1;
21297   {
21298     try {
21299       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
21300     } catch (std::out_of_range& e) {
21301       {
21302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21303       };
21304     } catch (std::exception& e) {
21305       {
21306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21307       };
21308     } catch (...) {
21309       {
21310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21311       };
21312     }
21313   }
21314   jresult = result;
21315   return jresult;
21316 }
21317
21318
21319 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
21320   unsigned int jresult ;
21321   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21322   unsigned int result;
21323
21324   arg1 = (Dali::PixelData *)jarg1;
21325   {
21326     try {
21327       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
21328     } catch (std::out_of_range& e) {
21329       {
21330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21331       };
21332     } catch (std::exception& e) {
21333       {
21334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21335       };
21336     } catch (...) {
21337       {
21338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21339       };
21340     }
21341   }
21342   jresult = result;
21343   return jresult;
21344 }
21345
21346
21347 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
21348   int jresult ;
21349   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21350   Dali::Pixel::Format result;
21351
21352   arg1 = (Dali::PixelData *)jarg1;
21353   {
21354     try {
21355       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
21356     } catch (std::out_of_range& e) {
21357       {
21358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21359       };
21360     } catch (std::exception& e) {
21361       {
21362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21363       };
21364     } catch (...) {
21365       {
21366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21367       };
21368     }
21369   }
21370   jresult = (int)result;
21371   return jresult;
21372 }
21373
21374
21375 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
21376   unsigned int jresult ;
21377   unsigned int result;
21378
21379   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
21380   jresult = result;
21381   return jresult;
21382 }
21383
21384
21385 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
21386   unsigned int jresult ;
21387   unsigned int result;
21388
21389   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
21390   jresult = result;
21391   return jresult;
21392 }
21393
21394
21395 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
21396   unsigned int jresult ;
21397   unsigned int result;
21398
21399   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
21400   jresult = result;
21401   return jresult;
21402 }
21403
21404
21405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
21406   unsigned int jresult ;
21407   unsigned int result;
21408
21409   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
21410   jresult = result;
21411   return jresult;
21412 }
21413
21414
21415 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
21416   unsigned int jresult ;
21417   unsigned int result;
21418
21419   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
21420   jresult = result;
21421   return jresult;
21422 }
21423
21424
21425 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
21426   unsigned int jresult ;
21427   unsigned int result;
21428
21429   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
21430   jresult = result;
21431   return jresult;
21432 }
21433
21434
21435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
21436   void * jresult ;
21437   Dali::TextureType::Type arg1 ;
21438   Dali::Pixel::Format arg2 ;
21439   unsigned int arg3 ;
21440   unsigned int arg4 ;
21441   Dali::Texture result;
21442
21443   arg1 = (Dali::TextureType::Type)jarg1;
21444   arg2 = (Dali::Pixel::Format)jarg2;
21445   arg3 = (unsigned int)jarg3;
21446   arg4 = (unsigned int)jarg4;
21447   {
21448     try {
21449       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
21450     } catch (std::out_of_range& e) {
21451       {
21452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21453       };
21454     } catch (std::exception& e) {
21455       {
21456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21457       };
21458     } catch (...) {
21459       {
21460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21461       };
21462     }
21463   }
21464   jresult = new Dali::Texture((const Dali::Texture &)result);
21465   return jresult;
21466 }
21467
21468
21469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
21470   void * jresult ;
21471   NativeImageInterface *arg1 = 0 ;
21472   Dali::Texture result;
21473
21474   arg1 = (NativeImageInterface *)jarg1;
21475   if (!arg1) {
21476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
21477     return 0;
21478   }
21479   {
21480     try {
21481       result = Dali::Texture::New(*arg1);
21482     } catch (std::out_of_range& e) {
21483       {
21484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21485       };
21486     } catch (std::exception& e) {
21487       {
21488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21489       };
21490     } catch (...) {
21491       {
21492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21493       };
21494     }
21495   }
21496   jresult = new Dali::Texture((const Dali::Texture &)result);
21497   return jresult;
21498 }
21499
21500
21501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
21502   void * jresult ;
21503   Dali::Texture *result = 0 ;
21504
21505   {
21506     try {
21507       result = (Dali::Texture *)new Dali::Texture();
21508     } catch (std::out_of_range& e) {
21509       {
21510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21511       };
21512     } catch (std::exception& e) {
21513       {
21514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21515       };
21516     } catch (...) {
21517       {
21518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21519       };
21520     }
21521   }
21522   jresult = (void *)result;
21523   return jresult;
21524 }
21525
21526
21527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
21528   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21529
21530   arg1 = (Dali::Texture *)jarg1;
21531   {
21532     try {
21533       delete arg1;
21534     } catch (std::out_of_range& e) {
21535       {
21536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21537       };
21538     } catch (std::exception& e) {
21539       {
21540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21541       };
21542     } catch (...) {
21543       {
21544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21545       };
21546     }
21547   }
21548 }
21549
21550
21551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
21552   void * jresult ;
21553   Dali::Texture *arg1 = 0 ;
21554   Dali::Texture *result = 0 ;
21555
21556   arg1 = (Dali::Texture *)jarg1;
21557   if (!arg1) {
21558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21559     return 0;
21560   }
21561   {
21562     try {
21563       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
21564     } catch (std::out_of_range& e) {
21565       {
21566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21567       };
21568     } catch (std::exception& e) {
21569       {
21570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21571       };
21572     } catch (...) {
21573       {
21574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21575       };
21576     }
21577   }
21578   jresult = (void *)result;
21579   return jresult;
21580 }
21581
21582
21583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
21584   void * jresult ;
21585   Dali::BaseHandle arg1 ;
21586   Dali::BaseHandle *argp1 ;
21587   Dali::Texture result;
21588
21589   argp1 = (Dali::BaseHandle *)jarg1;
21590   if (!argp1) {
21591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21592     return 0;
21593   }
21594   arg1 = *argp1;
21595   {
21596     try {
21597       result = Dali::Texture::DownCast(arg1);
21598     } catch (std::out_of_range& e) {
21599       {
21600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21601       };
21602     } catch (std::exception& e) {
21603       {
21604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21605       };
21606     } catch (...) {
21607       {
21608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21609       };
21610     }
21611   }
21612   jresult = new Dali::Texture((const Dali::Texture &)result);
21613   return jresult;
21614 }
21615
21616
21617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
21618   void * jresult ;
21619   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21620   Dali::Texture *arg2 = 0 ;
21621   Dali::Texture *result = 0 ;
21622
21623   arg1 = (Dali::Texture *)jarg1;
21624   arg2 = (Dali::Texture *)jarg2;
21625   if (!arg2) {
21626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21627     return 0;
21628   }
21629   {
21630     try {
21631       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
21632     } catch (std::out_of_range& e) {
21633       {
21634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21635       };
21636     } catch (std::exception& e) {
21637       {
21638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21639       };
21640     } catch (...) {
21641       {
21642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21643       };
21644     }
21645   }
21646   jresult = (void *)result;
21647   return jresult;
21648 }
21649
21650
21651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
21652   unsigned int jresult ;
21653   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21654   Dali::PixelData arg2 ;
21655   Dali::PixelData *argp2 ;
21656   bool result;
21657
21658   arg1 = (Dali::Texture *)jarg1;
21659   argp2 = (Dali::PixelData *)jarg2;
21660   if (!argp2) {
21661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21662     return 0;
21663   }
21664   arg2 = *argp2;
21665   {
21666     try {
21667       result = (bool)(arg1)->Upload(arg2);
21668     } catch (std::out_of_range& e) {
21669       {
21670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21671       };
21672     } catch (std::exception& e) {
21673       {
21674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21675       };
21676     } catch (...) {
21677       {
21678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21679       };
21680     }
21681   }
21682   jresult = result;
21683   return jresult;
21684 }
21685
21686
21687 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) {
21688   unsigned int jresult ;
21689   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21690   Dali::PixelData arg2 ;
21691   unsigned int arg3 ;
21692   unsigned int arg4 ;
21693   unsigned int arg5 ;
21694   unsigned int arg6 ;
21695   unsigned int arg7 ;
21696   unsigned int arg8 ;
21697   Dali::PixelData *argp2 ;
21698   bool result;
21699
21700   arg1 = (Dali::Texture *)jarg1;
21701   argp2 = (Dali::PixelData *)jarg2;
21702   if (!argp2) {
21703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21704     return 0;
21705   }
21706   arg2 = *argp2;
21707   arg3 = (unsigned int)jarg3;
21708   arg4 = (unsigned int)jarg4;
21709   arg5 = (unsigned int)jarg5;
21710   arg6 = (unsigned int)jarg6;
21711   arg7 = (unsigned int)jarg7;
21712   arg8 = (unsigned int)jarg8;
21713   {
21714     try {
21715       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
21716     } catch (std::out_of_range& e) {
21717       {
21718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21719       };
21720     } catch (std::exception& e) {
21721       {
21722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21723       };
21724     } catch (...) {
21725       {
21726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21727       };
21728     }
21729   }
21730   jresult = result;
21731   return jresult;
21732 }
21733
21734
21735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
21736   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21737
21738   arg1 = (Dali::Texture *)jarg1;
21739   {
21740     try {
21741       (arg1)->GenerateMipmaps();
21742     } catch (std::out_of_range& e) {
21743       {
21744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21745       };
21746     } catch (std::exception& e) {
21747       {
21748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21749       };
21750     } catch (...) {
21751       {
21752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21753       };
21754     }
21755   }
21756 }
21757
21758
21759 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
21760   unsigned int jresult ;
21761   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21762   unsigned int result;
21763
21764   arg1 = (Dali::Texture *)jarg1;
21765   {
21766     try {
21767       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
21768     } catch (std::out_of_range& e) {
21769       {
21770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21771       };
21772     } catch (std::exception& e) {
21773       {
21774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21775       };
21776     } catch (...) {
21777       {
21778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21779       };
21780     }
21781   }
21782   jresult = result;
21783   return jresult;
21784 }
21785
21786
21787 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
21788   unsigned int jresult ;
21789   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21790   unsigned int result;
21791
21792   arg1 = (Dali::Texture *)jarg1;
21793   {
21794     try {
21795       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
21796     } catch (std::out_of_range& e) {
21797       {
21798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21799       };
21800     } catch (std::exception& e) {
21801       {
21802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21803       };
21804     } catch (...) {
21805       {
21806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21807       };
21808     }
21809   }
21810   jresult = result;
21811   return jresult;
21812 }
21813
21814
21815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_2(void * jarg1) {
21816   void * jresult ;
21817   Dali::Internal::Texture *arg1 = (Dali::Internal::Texture *) 0 ;
21818   Dali::Texture *result = 0 ;
21819
21820   arg1 = (Dali::Internal::Texture *)jarg1;
21821   {
21822     try {
21823       result = (Dali::Texture *)new Dali::Texture(arg1);
21824     } catch (std::out_of_range& e) {
21825       {
21826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21827       };
21828     } catch (std::exception& e) {
21829       {
21830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21831       };
21832     } catch (...) {
21833       {
21834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21835       };
21836     }
21837   }
21838   jresult = (void *)result;
21839   return jresult;
21840 }
21841
21842
21843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
21844   void * jresult ;
21845   Dali::Sampler result;
21846
21847   {
21848     try {
21849       result = Dali::Sampler::New();
21850     } catch (std::out_of_range& e) {
21851       {
21852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21853       };
21854     } catch (std::exception& e) {
21855       {
21856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21857       };
21858     } catch (...) {
21859       {
21860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21861       };
21862     }
21863   }
21864   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21865   return jresult;
21866 }
21867
21868
21869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
21870   void * jresult ;
21871   Dali::Sampler *result = 0 ;
21872
21873   {
21874     try {
21875       result = (Dali::Sampler *)new Dali::Sampler();
21876     } catch (std::out_of_range& e) {
21877       {
21878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21879       };
21880     } catch (std::exception& e) {
21881       {
21882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21883       };
21884     } catch (...) {
21885       {
21886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21887       };
21888     }
21889   }
21890   jresult = (void *)result;
21891   return jresult;
21892 }
21893
21894
21895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
21896   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21897
21898   arg1 = (Dali::Sampler *)jarg1;
21899   {
21900     try {
21901       delete arg1;
21902     } catch (std::out_of_range& e) {
21903       {
21904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21905       };
21906     } catch (std::exception& e) {
21907       {
21908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21909       };
21910     } catch (...) {
21911       {
21912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21913       };
21914     }
21915   }
21916 }
21917
21918
21919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
21920   void * jresult ;
21921   Dali::Sampler *arg1 = 0 ;
21922   Dali::Sampler *result = 0 ;
21923
21924   arg1 = (Dali::Sampler *)jarg1;
21925   if (!arg1) {
21926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21927     return 0;
21928   }
21929   {
21930     try {
21931       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
21932     } catch (std::out_of_range& e) {
21933       {
21934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21935       };
21936     } catch (std::exception& e) {
21937       {
21938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21939       };
21940     } catch (...) {
21941       {
21942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21943       };
21944     }
21945   }
21946   jresult = (void *)result;
21947   return jresult;
21948 }
21949
21950
21951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
21952   void * jresult ;
21953   Dali::BaseHandle arg1 ;
21954   Dali::BaseHandle *argp1 ;
21955   Dali::Sampler result;
21956
21957   argp1 = (Dali::BaseHandle *)jarg1;
21958   if (!argp1) {
21959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21960     return 0;
21961   }
21962   arg1 = *argp1;
21963   {
21964     try {
21965       result = Dali::Sampler::DownCast(arg1);
21966     } catch (std::out_of_range& e) {
21967       {
21968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21969       };
21970     } catch (std::exception& e) {
21971       {
21972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21973       };
21974     } catch (...) {
21975       {
21976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21977       };
21978     }
21979   }
21980   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21981   return jresult;
21982 }
21983
21984
21985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
21986   void * jresult ;
21987   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21988   Dali::Sampler *arg2 = 0 ;
21989   Dali::Sampler *result = 0 ;
21990
21991   arg1 = (Dali::Sampler *)jarg1;
21992   arg2 = (Dali::Sampler *)jarg2;
21993   if (!arg2) {
21994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21995     return 0;
21996   }
21997   {
21998     try {
21999       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
22000     } catch (std::out_of_range& e) {
22001       {
22002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22003       };
22004     } catch (std::exception& e) {
22005       {
22006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22007       };
22008     } catch (...) {
22009       {
22010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22011       };
22012     }
22013   }
22014   jresult = (void *)result;
22015   return jresult;
22016 }
22017
22018
22019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
22020   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
22021   Dali::FilterMode::Type arg2 ;
22022   Dali::FilterMode::Type arg3 ;
22023
22024   arg1 = (Dali::Sampler *)jarg1;
22025   arg2 = (Dali::FilterMode::Type)jarg2;
22026   arg3 = (Dali::FilterMode::Type)jarg3;
22027   {
22028     try {
22029       (arg1)->SetFilterMode(arg2,arg3);
22030     } catch (std::out_of_range& e) {
22031       {
22032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22033       };
22034     } catch (std::exception& e) {
22035       {
22036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22037       };
22038     } catch (...) {
22039       {
22040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22041       };
22042     }
22043   }
22044 }
22045
22046
22047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
22048   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
22049   Dali::WrapMode::Type arg2 ;
22050   Dali::WrapMode::Type arg3 ;
22051
22052   arg1 = (Dali::Sampler *)jarg1;
22053   arg2 = (Dali::WrapMode::Type)jarg2;
22054   arg3 = (Dali::WrapMode::Type)jarg3;
22055   {
22056     try {
22057       (arg1)->SetWrapMode(arg2,arg3);
22058     } catch (std::out_of_range& e) {
22059       {
22060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22061       };
22062     } catch (std::exception& e) {
22063       {
22064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22065       };
22066     } catch (...) {
22067       {
22068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22069       };
22070     }
22071   }
22072 }
22073
22074
22075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
22076   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
22077   Dali::WrapMode::Type arg2 ;
22078   Dali::WrapMode::Type arg3 ;
22079   Dali::WrapMode::Type arg4 ;
22080
22081   arg1 = (Dali::Sampler *)jarg1;
22082   arg2 = (Dali::WrapMode::Type)jarg2;
22083   arg3 = (Dali::WrapMode::Type)jarg3;
22084   arg4 = (Dali::WrapMode::Type)jarg4;
22085   {
22086     try {
22087       (arg1)->SetWrapMode(arg2,arg3,arg4);
22088     } catch (std::out_of_range& e) {
22089       {
22090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22091       };
22092     } catch (std::exception& e) {
22093       {
22094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22095       };
22096     } catch (...) {
22097       {
22098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22099       };
22100     }
22101   }
22102 }
22103
22104
22105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
22106   void * jresult ;
22107   Dali::TextureSet result;
22108
22109   {
22110     try {
22111       result = Dali::TextureSet::New();
22112     } catch (std::out_of_range& e) {
22113       {
22114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22115       };
22116     } catch (std::exception& e) {
22117       {
22118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22119       };
22120     } catch (...) {
22121       {
22122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22123       };
22124     }
22125   }
22126   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22127   return jresult;
22128 }
22129
22130
22131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
22132   void * jresult ;
22133   Dali::TextureSet *result = 0 ;
22134
22135   {
22136     try {
22137       result = (Dali::TextureSet *)new Dali::TextureSet();
22138     } catch (std::out_of_range& e) {
22139       {
22140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22141       };
22142     } catch (std::exception& e) {
22143       {
22144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22145       };
22146     } catch (...) {
22147       {
22148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22149       };
22150     }
22151   }
22152   jresult = (void *)result;
22153   return jresult;
22154 }
22155
22156
22157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
22158   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22159
22160   arg1 = (Dali::TextureSet *)jarg1;
22161   {
22162     try {
22163       delete arg1;
22164     } catch (std::out_of_range& e) {
22165       {
22166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22167       };
22168     } catch (std::exception& e) {
22169       {
22170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22171       };
22172     } catch (...) {
22173       {
22174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22175       };
22176     }
22177   }
22178 }
22179
22180
22181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
22182   void * jresult ;
22183   Dali::TextureSet *arg1 = 0 ;
22184   Dali::TextureSet *result = 0 ;
22185
22186   arg1 = (Dali::TextureSet *)jarg1;
22187   if (!arg1) {
22188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22189     return 0;
22190   }
22191   {
22192     try {
22193       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
22194     } catch (std::out_of_range& e) {
22195       {
22196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22197       };
22198     } catch (std::exception& e) {
22199       {
22200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22201       };
22202     } catch (...) {
22203       {
22204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22205       };
22206     }
22207   }
22208   jresult = (void *)result;
22209   return jresult;
22210 }
22211
22212
22213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
22214   void * jresult ;
22215   Dali::BaseHandle arg1 ;
22216   Dali::BaseHandle *argp1 ;
22217   Dali::TextureSet result;
22218
22219   argp1 = (Dali::BaseHandle *)jarg1;
22220   if (!argp1) {
22221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22222     return 0;
22223   }
22224   arg1 = *argp1;
22225   {
22226     try {
22227       result = Dali::TextureSet::DownCast(arg1);
22228     } catch (std::out_of_range& e) {
22229       {
22230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22231       };
22232     } catch (std::exception& e) {
22233       {
22234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22235       };
22236     } catch (...) {
22237       {
22238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22239       };
22240     }
22241   }
22242   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22243   return jresult;
22244 }
22245
22246
22247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
22248   void * jresult ;
22249   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22250   Dali::TextureSet *arg2 = 0 ;
22251   Dali::TextureSet *result = 0 ;
22252
22253   arg1 = (Dali::TextureSet *)jarg1;
22254   arg2 = (Dali::TextureSet *)jarg2;
22255   if (!arg2) {
22256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22257     return 0;
22258   }
22259   {
22260     try {
22261       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
22262     } catch (std::out_of_range& e) {
22263       {
22264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22265       };
22266     } catch (std::exception& e) {
22267       {
22268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22269       };
22270     } catch (...) {
22271       {
22272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22273       };
22274     }
22275   }
22276   jresult = (void *)result;
22277   return jresult;
22278 }
22279
22280
22281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
22282   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22283   size_t arg2 ;
22284   Dali::Texture arg3 ;
22285   Dali::Texture *argp3 ;
22286
22287   arg1 = (Dali::TextureSet *)jarg1;
22288   arg2 = (size_t)jarg2;
22289   argp3 = (Dali::Texture *)jarg3;
22290   if (!argp3) {
22291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
22292     return ;
22293   }
22294   arg3 = *argp3;
22295   {
22296     try {
22297       (arg1)->SetTexture(arg2,arg3);
22298     } catch (std::out_of_range& e) {
22299       {
22300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22301       };
22302     } catch (std::exception& e) {
22303       {
22304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22305       };
22306     } catch (...) {
22307       {
22308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22309       };
22310     }
22311   }
22312 }
22313
22314
22315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
22316   void * jresult ;
22317   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22318   size_t arg2 ;
22319   Dali::Texture result;
22320
22321   arg1 = (Dali::TextureSet *)jarg1;
22322   arg2 = (size_t)jarg2;
22323   {
22324     try {
22325       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
22326     } catch (std::out_of_range& e) {
22327       {
22328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22329       };
22330     } catch (std::exception& e) {
22331       {
22332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22333       };
22334     } catch (...) {
22335       {
22336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22337       };
22338     }
22339   }
22340   jresult = new Dali::Texture((const Dali::Texture &)result);
22341   return jresult;
22342 }
22343
22344
22345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
22346   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22347   size_t arg2 ;
22348   Dali::Sampler arg3 ;
22349   Dali::Sampler *argp3 ;
22350
22351   arg1 = (Dali::TextureSet *)jarg1;
22352   arg2 = (size_t)jarg2;
22353   argp3 = (Dali::Sampler *)jarg3;
22354   if (!argp3) {
22355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
22356     return ;
22357   }
22358   arg3 = *argp3;
22359   {
22360     try {
22361       (arg1)->SetSampler(arg2,arg3);
22362     } catch (std::out_of_range& e) {
22363       {
22364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22365       };
22366     } catch (std::exception& e) {
22367       {
22368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22369       };
22370     } catch (...) {
22371       {
22372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22373       };
22374     }
22375   }
22376 }
22377
22378
22379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
22380   void * jresult ;
22381   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22382   size_t arg2 ;
22383   Dali::Sampler result;
22384
22385   arg1 = (Dali::TextureSet *)jarg1;
22386   arg2 = (size_t)jarg2;
22387   {
22388     try {
22389       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
22390     } catch (std::out_of_range& e) {
22391       {
22392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22393       };
22394     } catch (std::exception& e) {
22395       {
22396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22397       };
22398     } catch (...) {
22399       {
22400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22401       };
22402     }
22403   }
22404   jresult = new Dali::Sampler((const Dali::Sampler &)result);
22405   return jresult;
22406 }
22407
22408
22409 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
22410   unsigned long jresult ;
22411   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22412   size_t result;
22413
22414   arg1 = (Dali::TextureSet *)jarg1;
22415   {
22416     try {
22417       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
22418     } catch (std::out_of_range& e) {
22419       {
22420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22421       };
22422     } catch (std::exception& e) {
22423       {
22424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22425       };
22426     } catch (...) {
22427       {
22428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22429       };
22430     }
22431   }
22432   jresult = (unsigned long)result;
22433   return jresult;
22434 }
22435
22436
22437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
22438   void * jresult ;
22439   Dali::Property::Map *arg1 = 0 ;
22440   Dali::PropertyBuffer result;
22441
22442   arg1 = (Dali::Property::Map *)jarg1;
22443   if (!arg1) {
22444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
22445     return 0;
22446   }
22447   {
22448     try {
22449       result = Dali::PropertyBuffer::New(*arg1);
22450     } catch (std::out_of_range& e) {
22451       {
22452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22453       };
22454     } catch (std::exception& e) {
22455       {
22456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22457       };
22458     } catch (...) {
22459       {
22460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22461       };
22462     }
22463   }
22464   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22465   return jresult;
22466 }
22467
22468
22469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
22470   void * jresult ;
22471   Dali::PropertyBuffer *result = 0 ;
22472
22473   {
22474     try {
22475       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
22476     } catch (std::out_of_range& e) {
22477       {
22478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22479       };
22480     } catch (std::exception& e) {
22481       {
22482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22483       };
22484     } catch (...) {
22485       {
22486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22487       };
22488     }
22489   }
22490   jresult = (void *)result;
22491   return jresult;
22492 }
22493
22494
22495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
22496   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22497
22498   arg1 = (Dali::PropertyBuffer *)jarg1;
22499   {
22500     try {
22501       delete arg1;
22502     } catch (std::out_of_range& e) {
22503       {
22504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22505       };
22506     } catch (std::exception& e) {
22507       {
22508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22509       };
22510     } catch (...) {
22511       {
22512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22513       };
22514     }
22515   }
22516 }
22517
22518
22519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
22520   void * jresult ;
22521   Dali::PropertyBuffer *arg1 = 0 ;
22522   Dali::PropertyBuffer *result = 0 ;
22523
22524   arg1 = (Dali::PropertyBuffer *)jarg1;
22525   if (!arg1) {
22526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22527     return 0;
22528   }
22529   {
22530     try {
22531       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
22532     } catch (std::out_of_range& e) {
22533       {
22534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22535       };
22536     } catch (std::exception& e) {
22537       {
22538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22539       };
22540     } catch (...) {
22541       {
22542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22543       };
22544     }
22545   }
22546   jresult = (void *)result;
22547   return jresult;
22548 }
22549
22550
22551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
22552   void * jresult ;
22553   Dali::BaseHandle arg1 ;
22554   Dali::BaseHandle *argp1 ;
22555   Dali::PropertyBuffer result;
22556
22557   argp1 = (Dali::BaseHandle *)jarg1;
22558   if (!argp1) {
22559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22560     return 0;
22561   }
22562   arg1 = *argp1;
22563   {
22564     try {
22565       result = Dali::PropertyBuffer::DownCast(arg1);
22566     } catch (std::out_of_range& e) {
22567       {
22568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22569       };
22570     } catch (std::exception& e) {
22571       {
22572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22573       };
22574     } catch (...) {
22575       {
22576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22577       };
22578     }
22579   }
22580   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22581   return jresult;
22582 }
22583
22584
22585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
22586   void * jresult ;
22587   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22588   Dali::PropertyBuffer *arg2 = 0 ;
22589   Dali::PropertyBuffer *result = 0 ;
22590
22591   arg1 = (Dali::PropertyBuffer *)jarg1;
22592   arg2 = (Dali::PropertyBuffer *)jarg2;
22593   if (!arg2) {
22594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22595     return 0;
22596   }
22597   {
22598     try {
22599       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
22600     } catch (std::out_of_range& e) {
22601       {
22602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22603       };
22604     } catch (std::exception& e) {
22605       {
22606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22607       };
22608     } catch (...) {
22609       {
22610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22611       };
22612     }
22613   }
22614   jresult = (void *)result;
22615   return jresult;
22616 }
22617
22618
22619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
22620   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22621   void *arg2 = (void *) 0 ;
22622   std::size_t arg3 ;
22623
22624   arg1 = (Dali::PropertyBuffer *)jarg1;
22625   arg2 = jarg2;
22626   arg3 = (std::size_t)jarg3;
22627   {
22628     try {
22629       (arg1)->SetData((void const *)arg2,arg3);
22630     } catch (std::out_of_range& e) {
22631       {
22632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22633       };
22634     } catch (std::exception& e) {
22635       {
22636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22637       };
22638     } catch (...) {
22639       {
22640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22641       };
22642     }
22643   }
22644 }
22645
22646
22647 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
22648   unsigned long jresult ;
22649   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22650   std::size_t result;
22651
22652   arg1 = (Dali::PropertyBuffer *)jarg1;
22653   {
22654     try {
22655       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
22656     } catch (std::out_of_range& e) {
22657       {
22658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22659       };
22660     } catch (std::exception& e) {
22661       {
22662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22663       };
22664     } catch (...) {
22665       {
22666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22667       };
22668     }
22669   }
22670   jresult = (unsigned long)result;
22671   return jresult;
22672 }
22673
22674
22675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
22676   void * jresult ;
22677   Dali::Geometry result;
22678
22679   {
22680     try {
22681       result = Dali::Geometry::New();
22682     } catch (std::out_of_range& e) {
22683       {
22684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22685       };
22686     } catch (std::exception& e) {
22687       {
22688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22689       };
22690     } catch (...) {
22691       {
22692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22693       };
22694     }
22695   }
22696   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22697   return jresult;
22698 }
22699
22700
22701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
22702   void * jresult ;
22703   Dali::Geometry *result = 0 ;
22704
22705   {
22706     try {
22707       result = (Dali::Geometry *)new Dali::Geometry();
22708     } catch (std::out_of_range& e) {
22709       {
22710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22711       };
22712     } catch (std::exception& e) {
22713       {
22714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22715       };
22716     } catch (...) {
22717       {
22718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22719       };
22720     }
22721   }
22722   jresult = (void *)result;
22723   return jresult;
22724 }
22725
22726
22727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
22728   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22729
22730   arg1 = (Dali::Geometry *)jarg1;
22731   {
22732     try {
22733       delete arg1;
22734     } catch (std::out_of_range& e) {
22735       {
22736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22737       };
22738     } catch (std::exception& e) {
22739       {
22740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22741       };
22742     } catch (...) {
22743       {
22744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22745       };
22746     }
22747   }
22748 }
22749
22750
22751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
22752   void * jresult ;
22753   Dali::Geometry *arg1 = 0 ;
22754   Dali::Geometry *result = 0 ;
22755
22756   arg1 = (Dali::Geometry *)jarg1;
22757   if (!arg1) {
22758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22759     return 0;
22760   }
22761   {
22762     try {
22763       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
22764     } catch (std::out_of_range& e) {
22765       {
22766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22767       };
22768     } catch (std::exception& e) {
22769       {
22770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22771       };
22772     } catch (...) {
22773       {
22774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22775       };
22776     }
22777   }
22778   jresult = (void *)result;
22779   return jresult;
22780 }
22781
22782
22783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
22784   void * jresult ;
22785   Dali::BaseHandle arg1 ;
22786   Dali::BaseHandle *argp1 ;
22787   Dali::Geometry result;
22788
22789   argp1 = (Dali::BaseHandle *)jarg1;
22790   if (!argp1) {
22791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22792     return 0;
22793   }
22794   arg1 = *argp1;
22795   {
22796     try {
22797       result = Dali::Geometry::DownCast(arg1);
22798     } catch (std::out_of_range& e) {
22799       {
22800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22801       };
22802     } catch (std::exception& e) {
22803       {
22804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22805       };
22806     } catch (...) {
22807       {
22808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22809       };
22810     }
22811   }
22812   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22813   return jresult;
22814 }
22815
22816
22817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
22818   void * jresult ;
22819   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22820   Dali::Geometry *arg2 = 0 ;
22821   Dali::Geometry *result = 0 ;
22822
22823   arg1 = (Dali::Geometry *)jarg1;
22824   arg2 = (Dali::Geometry *)jarg2;
22825   if (!arg2) {
22826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22827     return 0;
22828   }
22829   {
22830     try {
22831       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
22832     } catch (std::out_of_range& e) {
22833       {
22834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22835       };
22836     } catch (std::exception& e) {
22837       {
22838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22839       };
22840     } catch (...) {
22841       {
22842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22843       };
22844     }
22845   }
22846   jresult = (void *)result;
22847   return jresult;
22848 }
22849
22850
22851 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
22852   unsigned long jresult ;
22853   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22854   Dali::PropertyBuffer *arg2 = 0 ;
22855   std::size_t result;
22856
22857   arg1 = (Dali::Geometry *)jarg1;
22858   arg2 = (Dali::PropertyBuffer *)jarg2;
22859   if (!arg2) {
22860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
22861     return 0;
22862   }
22863   {
22864     try {
22865       result = (arg1)->AddVertexBuffer(*arg2);
22866     } catch (std::out_of_range& e) {
22867       {
22868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22869       };
22870     } catch (std::exception& e) {
22871       {
22872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22873       };
22874     } catch (...) {
22875       {
22876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22877       };
22878     }
22879   }
22880   jresult = (unsigned long)result;
22881   return jresult;
22882 }
22883
22884
22885 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
22886   unsigned long jresult ;
22887   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22888   std::size_t result;
22889
22890   arg1 = (Dali::Geometry *)jarg1;
22891   {
22892     try {
22893       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
22894     } catch (std::out_of_range& e) {
22895       {
22896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22897       };
22898     } catch (std::exception& e) {
22899       {
22900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22901       };
22902     } catch (...) {
22903       {
22904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22905       };
22906     }
22907   }
22908   jresult = (unsigned long)result;
22909   return jresult;
22910 }
22911
22912
22913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
22914   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22915   std::size_t arg2 ;
22916
22917   arg1 = (Dali::Geometry *)jarg1;
22918   arg2 = (std::size_t)jarg2;
22919   {
22920     try {
22921       (arg1)->RemoveVertexBuffer(arg2);
22922     } catch (std::out_of_range& e) {
22923       {
22924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22925       };
22926     } catch (std::exception& e) {
22927       {
22928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22929       };
22930     } catch (...) {
22931       {
22932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22933       };
22934     }
22935   }
22936 }
22937
22938
22939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
22940   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22941   unsigned short *arg2 = (unsigned short *) 0 ;
22942   size_t arg3 ;
22943
22944   arg1 = (Dali::Geometry *)jarg1;
22945   arg2 = jarg2;
22946   arg3 = (size_t)jarg3;
22947   {
22948     try {
22949       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
22950     } catch (std::out_of_range& e) {
22951       {
22952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22953       };
22954     } catch (std::exception& e) {
22955       {
22956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22957       };
22958     } catch (...) {
22959       {
22960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22961       };
22962     }
22963   }
22964
22965
22966 }
22967
22968
22969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
22970   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22971   Dali::Geometry::Type arg2 ;
22972
22973   arg1 = (Dali::Geometry *)jarg1;
22974   arg2 = (Dali::Geometry::Type)jarg2;
22975   {
22976     try {
22977       (arg1)->SetType(arg2);
22978     } catch (std::out_of_range& e) {
22979       {
22980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22981       };
22982     } catch (std::exception& e) {
22983       {
22984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22985       };
22986     } catch (...) {
22987       {
22988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22989       };
22990     }
22991   }
22992 }
22993
22994
22995 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
22996   int jresult ;
22997   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22998   Dali::Geometry::Type result;
22999
23000   arg1 = (Dali::Geometry *)jarg1;
23001   {
23002     try {
23003       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
23004     } catch (std::out_of_range& e) {
23005       {
23006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23007       };
23008     } catch (std::exception& e) {
23009       {
23010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23011       };
23012     } catch (...) {
23013       {
23014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23015       };
23016     }
23017   }
23018   jresult = (int)result;
23019   return jresult;
23020 }
23021
23022
23023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
23024   void * jresult ;
23025   Dali::Shader::Hint *result = 0 ;
23026
23027   {
23028     try {
23029       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
23030     } catch (std::out_of_range& e) {
23031       {
23032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23033       };
23034     } catch (std::exception& e) {
23035       {
23036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23037       };
23038     } catch (...) {
23039       {
23040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23041       };
23042     }
23043   }
23044   jresult = (void *)result;
23045   return jresult;
23046 }
23047
23048
23049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
23050   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
23051
23052   arg1 = (Dali::Shader::Hint *)jarg1;
23053   {
23054     try {
23055       delete arg1;
23056     } catch (std::out_of_range& e) {
23057       {
23058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23059       };
23060     } catch (std::exception& e) {
23061       {
23062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23063       };
23064     } catch (...) {
23065       {
23066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23067       };
23068     }
23069   }
23070 }
23071
23072
23073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
23074   int jresult ;
23075   int result;
23076
23077   result = (int)Dali::Shader::Property::PROGRAM;
23078   jresult = (int)result;
23079   return jresult;
23080 }
23081
23082
23083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
23084   void * jresult ;
23085   Dali::Shader::Property *result = 0 ;
23086
23087   {
23088     try {
23089       result = (Dali::Shader::Property *)new Dali::Shader::Property();
23090     } catch (std::out_of_range& e) {
23091       {
23092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23093       };
23094     } catch (std::exception& e) {
23095       {
23096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23097       };
23098     } catch (...) {
23099       {
23100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23101       };
23102     }
23103   }
23104   jresult = (void *)result;
23105   return jresult;
23106 }
23107
23108
23109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
23110   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
23111
23112   arg1 = (Dali::Shader::Property *)jarg1;
23113   {
23114     try {
23115       delete arg1;
23116     } catch (std::out_of_range& e) {
23117       {
23118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23119       };
23120     } catch (std::exception& e) {
23121       {
23122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23123       };
23124     } catch (...) {
23125       {
23126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23127       };
23128     }
23129   }
23130 }
23131
23132
23133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
23134   void * jresult ;
23135   std::string *arg1 = 0 ;
23136   std::string *arg2 = 0 ;
23137   Dali::Shader::Hint::Value arg3 ;
23138   Dali::Shader result;
23139
23140   if (!jarg1) {
23141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23142     return 0;
23143   }
23144   std::string arg1_str(jarg1);
23145   arg1 = &arg1_str;
23146   if (!jarg2) {
23147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23148     return 0;
23149   }
23150   std::string arg2_str(jarg2);
23151   arg2 = &arg2_str;
23152   arg3 = (Dali::Shader::Hint::Value)jarg3;
23153   {
23154     try {
23155       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
23156     } catch (std::out_of_range& e) {
23157       {
23158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23159       };
23160     } catch (std::exception& e) {
23161       {
23162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23163       };
23164     } catch (...) {
23165       {
23166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23167       };
23168     }
23169   }
23170   jresult = new Dali::Shader((const Dali::Shader &)result);
23171
23172   //argout typemap for const std::string&
23173
23174
23175   //argout typemap for const std::string&
23176
23177   return jresult;
23178 }
23179
23180
23181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
23182   void * jresult ;
23183   std::string *arg1 = 0 ;
23184   std::string *arg2 = 0 ;
23185   Dali::Shader result;
23186
23187   if (!jarg1) {
23188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23189     return 0;
23190   }
23191   std::string arg1_str(jarg1);
23192   arg1 = &arg1_str;
23193   if (!jarg2) {
23194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23195     return 0;
23196   }
23197   std::string arg2_str(jarg2);
23198   arg2 = &arg2_str;
23199   {
23200     try {
23201       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
23202     } catch (std::out_of_range& e) {
23203       {
23204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23205       };
23206     } catch (std::exception& e) {
23207       {
23208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23209       };
23210     } catch (...) {
23211       {
23212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23213       };
23214     }
23215   }
23216   jresult = new Dali::Shader((const Dali::Shader &)result);
23217
23218   //argout typemap for const std::string&
23219
23220
23221   //argout typemap for const std::string&
23222
23223   return jresult;
23224 }
23225
23226
23227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
23228   void * jresult ;
23229   Dali::Shader *result = 0 ;
23230
23231   {
23232     try {
23233       result = (Dali::Shader *)new Dali::Shader();
23234     } catch (std::out_of_range& e) {
23235       {
23236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23237       };
23238     } catch (std::exception& e) {
23239       {
23240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23241       };
23242     } catch (...) {
23243       {
23244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23245       };
23246     }
23247   }
23248   jresult = (void *)result;
23249   return jresult;
23250 }
23251
23252
23253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
23254   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23255
23256   arg1 = (Dali::Shader *)jarg1;
23257   {
23258     try {
23259       delete arg1;
23260     } catch (std::out_of_range& e) {
23261       {
23262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23263       };
23264     } catch (std::exception& e) {
23265       {
23266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23267       };
23268     } catch (...) {
23269       {
23270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23271       };
23272     }
23273   }
23274 }
23275
23276
23277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
23278   void * jresult ;
23279   Dali::Shader *arg1 = 0 ;
23280   Dali::Shader *result = 0 ;
23281
23282   arg1 = (Dali::Shader *)jarg1;
23283   if (!arg1) {
23284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23285     return 0;
23286   }
23287   {
23288     try {
23289       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
23290     } catch (std::out_of_range& e) {
23291       {
23292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23293       };
23294     } catch (std::exception& e) {
23295       {
23296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23297       };
23298     } catch (...) {
23299       {
23300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23301       };
23302     }
23303   }
23304   jresult = (void *)result;
23305   return jresult;
23306 }
23307
23308
23309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
23310   void * jresult ;
23311   Dali::BaseHandle arg1 ;
23312   Dali::BaseHandle *argp1 ;
23313   Dali::Shader result;
23314
23315   argp1 = (Dali::BaseHandle *)jarg1;
23316   if (!argp1) {
23317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23318     return 0;
23319   }
23320   arg1 = *argp1;
23321   {
23322     try {
23323       result = Dali::Shader::DownCast(arg1);
23324     } catch (std::out_of_range& e) {
23325       {
23326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23327       };
23328     } catch (std::exception& e) {
23329       {
23330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23331       };
23332     } catch (...) {
23333       {
23334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23335       };
23336     }
23337   }
23338   jresult = new Dali::Shader((const Dali::Shader &)result);
23339   return jresult;
23340 }
23341
23342
23343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
23344   void * jresult ;
23345   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23346   Dali::Shader *arg2 = 0 ;
23347   Dali::Shader *result = 0 ;
23348
23349   arg1 = (Dali::Shader *)jarg1;
23350   arg2 = (Dali::Shader *)jarg2;
23351   if (!arg2) {
23352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23353     return 0;
23354   }
23355   {
23356     try {
23357       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
23358     } catch (std::out_of_range& e) {
23359       {
23360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23361       };
23362     } catch (std::exception& e) {
23363       {
23364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23365       };
23366     } catch (...) {
23367       {
23368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23369       };
23370     }
23371   }
23372   jresult = (void *)result;
23373   return jresult;
23374 }
23375
23376
23377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
23378   int jresult ;
23379   int result;
23380
23381   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
23382   jresult = (int)result;
23383   return jresult;
23384 }
23385
23386
23387 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
23388   int jresult ;
23389   int result;
23390
23391   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
23392   jresult = (int)result;
23393   return jresult;
23394 }
23395
23396
23397 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
23398   int jresult ;
23399   int result;
23400
23401   result = (int)Dali::Renderer::Property::BLEND_MODE;
23402   jresult = (int)result;
23403   return jresult;
23404 }
23405
23406
23407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
23408   int jresult ;
23409   int result;
23410
23411   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
23412   jresult = (int)result;
23413   return jresult;
23414 }
23415
23416
23417 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
23418   int jresult ;
23419   int result;
23420
23421   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
23422   jresult = (int)result;
23423   return jresult;
23424 }
23425
23426
23427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
23428   int jresult ;
23429   int result;
23430
23431   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
23432   jresult = (int)result;
23433   return jresult;
23434 }
23435
23436
23437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
23438   int jresult ;
23439   int result;
23440
23441   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
23442   jresult = (int)result;
23443   return jresult;
23444 }
23445
23446
23447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
23448   int jresult ;
23449   int result;
23450
23451   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
23452   jresult = (int)result;
23453   return jresult;
23454 }
23455
23456
23457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
23458   int jresult ;
23459   int result;
23460
23461   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
23462   jresult = (int)result;
23463   return jresult;
23464 }
23465
23466
23467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
23468   int jresult ;
23469   int result;
23470
23471   result = (int)Dali::Renderer::Property::BLEND_COLOR;
23472   jresult = (int)result;
23473   return jresult;
23474 }
23475
23476
23477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
23478   int jresult ;
23479   int result;
23480
23481   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
23482   jresult = (int)result;
23483   return jresult;
23484 }
23485
23486
23487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
23488   int jresult ;
23489   int result;
23490
23491   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
23492   jresult = (int)result;
23493   return jresult;
23494 }
23495
23496
23497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
23498   int jresult ;
23499   int result;
23500
23501   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
23502   jresult = (int)result;
23503   return jresult;
23504 }
23505
23506
23507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
23508   int jresult ;
23509   int result;
23510
23511   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
23512   jresult = (int)result;
23513   return jresult;
23514 }
23515
23516
23517 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
23518   int jresult ;
23519   int result;
23520
23521   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
23522   jresult = (int)result;
23523   return jresult;
23524 }
23525
23526
23527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
23528   int jresult ;
23529   int result;
23530
23531   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
23532   jresult = (int)result;
23533   return jresult;
23534 }
23535
23536
23537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
23538   int jresult ;
23539   int result;
23540
23541   result = (int)Dali::Renderer::Property::RENDER_MODE;
23542   jresult = (int)result;
23543   return jresult;
23544 }
23545
23546
23547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
23548   int jresult ;
23549   int result;
23550
23551   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
23552   jresult = (int)result;
23553   return jresult;
23554 }
23555
23556
23557 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
23558   int jresult ;
23559   int result;
23560
23561   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
23562   jresult = (int)result;
23563   return jresult;
23564 }
23565
23566
23567 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
23568   int jresult ;
23569   int result;
23570
23571   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
23572   jresult = (int)result;
23573   return jresult;
23574 }
23575
23576
23577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
23578   int jresult ;
23579   int result;
23580
23581   result = (int)Dali::Renderer::Property::STENCIL_MASK;
23582   jresult = (int)result;
23583   return jresult;
23584 }
23585
23586
23587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
23588   int jresult ;
23589   int result;
23590
23591   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
23592   jresult = (int)result;
23593   return jresult;
23594 }
23595
23596
23597 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
23598   int jresult ;
23599   int result;
23600
23601   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
23602   jresult = (int)result;
23603   return jresult;
23604 }
23605
23606
23607 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
23608   int jresult ;
23609   int result;
23610
23611   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
23612   jresult = (int)result;
23613   return jresult;
23614 }
23615
23616
23617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
23618   void * jresult ;
23619   Dali::Renderer::Property *result = 0 ;
23620
23621   {
23622     try {
23623       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
23624     } catch (std::out_of_range& e) {
23625       {
23626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23627       };
23628     } catch (std::exception& e) {
23629       {
23630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23631       };
23632     } catch (...) {
23633       {
23634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23635       };
23636     }
23637   }
23638   jresult = (void *)result;
23639   return jresult;
23640 }
23641
23642
23643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
23644   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
23645
23646   arg1 = (Dali::Renderer::Property *)jarg1;
23647   {
23648     try {
23649       delete arg1;
23650     } catch (std::out_of_range& e) {
23651       {
23652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23653       };
23654     } catch (std::exception& e) {
23655       {
23656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23657       };
23658     } catch (...) {
23659       {
23660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23661       };
23662     }
23663   }
23664 }
23665
23666
23667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
23668   void * jresult ;
23669   Dali::Geometry *arg1 = 0 ;
23670   Dali::Shader *arg2 = 0 ;
23671   Dali::Renderer result;
23672
23673   arg1 = (Dali::Geometry *)jarg1;
23674   if (!arg1) {
23675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23676     return 0;
23677   }
23678   arg2 = (Dali::Shader *)jarg2;
23679   if (!arg2) {
23680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23681     return 0;
23682   }
23683   {
23684     try {
23685       result = Dali::Renderer::New(*arg1,*arg2);
23686     } catch (std::out_of_range& e) {
23687       {
23688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23689       };
23690     } catch (std::exception& e) {
23691       {
23692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23693       };
23694     } catch (...) {
23695       {
23696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23697       };
23698     }
23699   }
23700   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23701   return jresult;
23702 }
23703
23704
23705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
23706   void * jresult ;
23707   Dali::Renderer *result = 0 ;
23708
23709   {
23710     try {
23711       result = (Dali::Renderer *)new Dali::Renderer();
23712     } catch (std::out_of_range& e) {
23713       {
23714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23715       };
23716     } catch (std::exception& e) {
23717       {
23718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23719       };
23720     } catch (...) {
23721       {
23722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23723       };
23724     }
23725   }
23726   jresult = (void *)result;
23727   return jresult;
23728 }
23729
23730
23731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
23732   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23733
23734   arg1 = (Dali::Renderer *)jarg1;
23735   {
23736     try {
23737       delete arg1;
23738     } catch (std::out_of_range& e) {
23739       {
23740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23741       };
23742     } catch (std::exception& e) {
23743       {
23744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23745       };
23746     } catch (...) {
23747       {
23748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23749       };
23750     }
23751   }
23752 }
23753
23754
23755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
23756   void * jresult ;
23757   Dali::Renderer *arg1 = 0 ;
23758   Dali::Renderer *result = 0 ;
23759
23760   arg1 = (Dali::Renderer *)jarg1;
23761   if (!arg1) {
23762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23763     return 0;
23764   }
23765   {
23766     try {
23767       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
23768     } catch (std::out_of_range& e) {
23769       {
23770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23771       };
23772     } catch (std::exception& e) {
23773       {
23774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23775       };
23776     } catch (...) {
23777       {
23778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23779       };
23780     }
23781   }
23782   jresult = (void *)result;
23783   return jresult;
23784 }
23785
23786
23787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
23788   void * jresult ;
23789   Dali::BaseHandle arg1 ;
23790   Dali::BaseHandle *argp1 ;
23791   Dali::Renderer result;
23792
23793   argp1 = (Dali::BaseHandle *)jarg1;
23794   if (!argp1) {
23795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23796     return 0;
23797   }
23798   arg1 = *argp1;
23799   {
23800     try {
23801       result = Dali::Renderer::DownCast(arg1);
23802     } catch (std::out_of_range& e) {
23803       {
23804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23805       };
23806     } catch (std::exception& e) {
23807       {
23808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23809       };
23810     } catch (...) {
23811       {
23812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23813       };
23814     }
23815   }
23816   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23817   return jresult;
23818 }
23819
23820
23821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
23822   void * jresult ;
23823   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23824   Dali::Renderer *arg2 = 0 ;
23825   Dali::Renderer *result = 0 ;
23826
23827   arg1 = (Dali::Renderer *)jarg1;
23828   arg2 = (Dali::Renderer *)jarg2;
23829   if (!arg2) {
23830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23831     return 0;
23832   }
23833   {
23834     try {
23835       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
23836     } catch (std::out_of_range& e) {
23837       {
23838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23839       };
23840     } catch (std::exception& e) {
23841       {
23842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23843       };
23844     } catch (...) {
23845       {
23846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23847       };
23848     }
23849   }
23850   jresult = (void *)result;
23851   return jresult;
23852 }
23853
23854
23855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
23856   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23857   Dali::Geometry *arg2 = 0 ;
23858
23859   arg1 = (Dali::Renderer *)jarg1;
23860   arg2 = (Dali::Geometry *)jarg2;
23861   if (!arg2) {
23862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23863     return ;
23864   }
23865   {
23866     try {
23867       (arg1)->SetGeometry(*arg2);
23868     } catch (std::out_of_range& e) {
23869       {
23870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23871       };
23872     } catch (std::exception& e) {
23873       {
23874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23875       };
23876     } catch (...) {
23877       {
23878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23879       };
23880     }
23881   }
23882 }
23883
23884
23885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
23886   void * jresult ;
23887   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23888   Dali::Geometry result;
23889
23890   arg1 = (Dali::Renderer *)jarg1;
23891   {
23892     try {
23893       result = ((Dali::Renderer const *)arg1)->GetGeometry();
23894     } catch (std::out_of_range& e) {
23895       {
23896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23897       };
23898     } catch (std::exception& e) {
23899       {
23900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23901       };
23902     } catch (...) {
23903       {
23904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23905       };
23906     }
23907   }
23908   jresult = new Dali::Geometry((const Dali::Geometry &)result);
23909   return jresult;
23910 }
23911
23912
23913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
23914   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23915   int arg2 ;
23916   int arg3 ;
23917
23918   arg1 = (Dali::Renderer *)jarg1;
23919   arg2 = (int)jarg2;
23920   arg3 = (int)jarg3;
23921   {
23922     try {
23923       (arg1)->SetIndexRange(arg2,arg3);
23924     } catch (std::out_of_range& e) {
23925       {
23926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23927       };
23928     } catch (std::exception& e) {
23929       {
23930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23931       };
23932     } catch (...) {
23933       {
23934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23935       };
23936     }
23937   }
23938 }
23939
23940
23941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
23942   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23943   Dali::TextureSet *arg2 = 0 ;
23944
23945   arg1 = (Dali::Renderer *)jarg1;
23946   arg2 = (Dali::TextureSet *)jarg2;
23947   if (!arg2) {
23948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
23949     return ;
23950   }
23951   {
23952     try {
23953       (arg1)->SetTextures(*arg2);
23954     } catch (std::out_of_range& e) {
23955       {
23956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23957       };
23958     } catch (std::exception& e) {
23959       {
23960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23961       };
23962     } catch (...) {
23963       {
23964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23965       };
23966     }
23967   }
23968 }
23969
23970
23971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
23972   void * jresult ;
23973   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23974   Dali::TextureSet result;
23975
23976   arg1 = (Dali::Renderer *)jarg1;
23977   {
23978     try {
23979       result = ((Dali::Renderer const *)arg1)->GetTextures();
23980     } catch (std::out_of_range& e) {
23981       {
23982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23983       };
23984     } catch (std::exception& e) {
23985       {
23986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23987       };
23988     } catch (...) {
23989       {
23990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23991       };
23992     }
23993   }
23994   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
23995   return jresult;
23996 }
23997
23998
23999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
24000   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
24001   Dali::Shader *arg2 = 0 ;
24002
24003   arg1 = (Dali::Renderer *)jarg1;
24004   arg2 = (Dali::Shader *)jarg2;
24005   if (!arg2) {
24006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
24007     return ;
24008   }
24009   {
24010     try {
24011       (arg1)->SetShader(*arg2);
24012     } catch (std::out_of_range& e) {
24013       {
24014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24015       };
24016     } catch (std::exception& e) {
24017       {
24018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24019       };
24020     } catch (...) {
24021       {
24022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24023       };
24024     }
24025   }
24026 }
24027
24028
24029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
24030   void * jresult ;
24031   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
24032   Dali::Shader result;
24033
24034   arg1 = (Dali::Renderer *)jarg1;
24035   {
24036     try {
24037       result = ((Dali::Renderer const *)arg1)->GetShader();
24038     } catch (std::out_of_range& e) {
24039       {
24040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24041       };
24042     } catch (std::exception& e) {
24043       {
24044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24045       };
24046     } catch (...) {
24047       {
24048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24049       };
24050     }
24051   }
24052   jresult = new Dali::Shader((const Dali::Shader &)result);
24053   return jresult;
24054 }
24055
24056
24057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
24058   void * jresult ;
24059   Dali::FrameBuffer::Attachment *result = 0 ;
24060
24061   {
24062     try {
24063       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
24064     } catch (std::out_of_range& e) {
24065       {
24066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24067       };
24068     } catch (std::exception& e) {
24069       {
24070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24071       };
24072     } catch (...) {
24073       {
24074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24075       };
24076     }
24077   }
24078   jresult = (void *)result;
24079   return jresult;
24080 }
24081
24082
24083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
24084   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
24085
24086   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
24087   {
24088     try {
24089       delete arg1;
24090     } catch (std::out_of_range& e) {
24091       {
24092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24093       };
24094     } catch (std::exception& e) {
24095       {
24096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24097       };
24098     } catch (...) {
24099       {
24100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24101       };
24102     }
24103   }
24104 }
24105
24106
24107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
24108   void * jresult ;
24109   unsigned int arg1 ;
24110   unsigned int arg2 ;
24111   unsigned int arg3 ;
24112   Dali::FrameBuffer result;
24113
24114   arg1 = (unsigned int)jarg1;
24115   arg2 = (unsigned int)jarg2;
24116   arg3 = (unsigned int)jarg3;
24117   {
24118     try {
24119       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
24120     } catch (std::out_of_range& e) {
24121       {
24122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24123       };
24124     } catch (std::exception& e) {
24125       {
24126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24127       };
24128     } catch (...) {
24129       {
24130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24131       };
24132     }
24133   }
24134   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24135   return jresult;
24136 }
24137
24138
24139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
24140   void * jresult ;
24141   Dali::FrameBuffer *result = 0 ;
24142
24143   {
24144     try {
24145       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
24146     } catch (std::out_of_range& e) {
24147       {
24148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24149       };
24150     } catch (std::exception& e) {
24151       {
24152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24153       };
24154     } catch (...) {
24155       {
24156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24157       };
24158     }
24159   }
24160   jresult = (void *)result;
24161   return jresult;
24162 }
24163
24164
24165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
24166   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24167
24168   arg1 = (Dali::FrameBuffer *)jarg1;
24169   {
24170     try {
24171       delete arg1;
24172     } catch (std::out_of_range& e) {
24173       {
24174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24175       };
24176     } catch (std::exception& e) {
24177       {
24178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24179       };
24180     } catch (...) {
24181       {
24182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24183       };
24184     }
24185   }
24186 }
24187
24188
24189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
24190   void * jresult ;
24191   Dali::FrameBuffer *arg1 = 0 ;
24192   Dali::FrameBuffer *result = 0 ;
24193
24194   arg1 = (Dali::FrameBuffer *)jarg1;
24195   if (!arg1) {
24196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24197     return 0;
24198   }
24199   {
24200     try {
24201       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
24202     } catch (std::out_of_range& e) {
24203       {
24204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24205       };
24206     } catch (std::exception& e) {
24207       {
24208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24209       };
24210     } catch (...) {
24211       {
24212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24213       };
24214     }
24215   }
24216   jresult = (void *)result;
24217   return jresult;
24218 }
24219
24220
24221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
24222   void * jresult ;
24223   Dali::BaseHandle arg1 ;
24224   Dali::BaseHandle *argp1 ;
24225   Dali::FrameBuffer result;
24226
24227   argp1 = (Dali::BaseHandle *)jarg1;
24228   if (!argp1) {
24229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24230     return 0;
24231   }
24232   arg1 = *argp1;
24233   {
24234     try {
24235       result = Dali::FrameBuffer::DownCast(arg1);
24236     } catch (std::out_of_range& e) {
24237       {
24238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24239       };
24240     } catch (std::exception& e) {
24241       {
24242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24243       };
24244     } catch (...) {
24245       {
24246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24247       };
24248     }
24249   }
24250   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24251   return jresult;
24252 }
24253
24254
24255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
24256   void * jresult ;
24257   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24258   Dali::FrameBuffer *arg2 = 0 ;
24259   Dali::FrameBuffer *result = 0 ;
24260
24261   arg1 = (Dali::FrameBuffer *)jarg1;
24262   arg2 = (Dali::FrameBuffer *)jarg2;
24263   if (!arg2) {
24264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24265     return 0;
24266   }
24267   {
24268     try {
24269       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
24270     } catch (std::out_of_range& e) {
24271       {
24272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24273       };
24274     } catch (std::exception& e) {
24275       {
24276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24277       };
24278     } catch (...) {
24279       {
24280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24281       };
24282     }
24283   }
24284   jresult = (void *)result;
24285   return jresult;
24286 }
24287
24288
24289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
24290   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24291   Dali::Texture *arg2 = 0 ;
24292
24293   arg1 = (Dali::FrameBuffer *)jarg1;
24294   arg2 = (Dali::Texture *)jarg2;
24295   if (!arg2) {
24296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24297     return ;
24298   }
24299   {
24300     try {
24301       (arg1)->AttachColorTexture(*arg2);
24302     } catch (std::out_of_range& e) {
24303       {
24304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24305       };
24306     } catch (std::exception& e) {
24307       {
24308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24309       };
24310     } catch (...) {
24311       {
24312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24313       };
24314     }
24315   }
24316 }
24317
24318
24319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
24320   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24321   Dali::Texture *arg2 = 0 ;
24322   unsigned int arg3 ;
24323   unsigned int arg4 ;
24324
24325   arg1 = (Dali::FrameBuffer *)jarg1;
24326   arg2 = (Dali::Texture *)jarg2;
24327   if (!arg2) {
24328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24329     return ;
24330   }
24331   arg3 = (unsigned int)jarg3;
24332   arg4 = (unsigned int)jarg4;
24333   {
24334     try {
24335       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
24336     } catch (std::out_of_range& e) {
24337       {
24338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24339       };
24340     } catch (std::exception& e) {
24341       {
24342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24343       };
24344     } catch (...) {
24345       {
24346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24347       };
24348     }
24349   }
24350 }
24351
24352
24353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
24354   void * jresult ;
24355   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24356   Dali::Texture result;
24357
24358   arg1 = (Dali::FrameBuffer *)jarg1;
24359   {
24360     try {
24361       result = (arg1)->GetColorTexture();
24362     } catch (std::out_of_range& e) {
24363       {
24364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24365       };
24366     } catch (std::exception& e) {
24367       {
24368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24369       };
24370     } catch (...) {
24371       {
24372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24373       };
24374     }
24375   }
24376   jresult = new Dali::Texture((const Dali::Texture &)result);
24377   return jresult;
24378 }
24379
24380
24381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
24382   void * jresult ;
24383   Dali::RenderTaskList *result = 0 ;
24384
24385   {
24386     try {
24387       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
24388     } catch (std::out_of_range& e) {
24389       {
24390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24391       };
24392     } catch (std::exception& e) {
24393       {
24394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24395       };
24396     } catch (...) {
24397       {
24398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24399       };
24400     }
24401   }
24402   jresult = (void *)result;
24403   return jresult;
24404 }
24405
24406
24407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
24408   void * jresult ;
24409   Dali::BaseHandle arg1 ;
24410   Dali::BaseHandle *argp1 ;
24411   Dali::RenderTaskList result;
24412
24413   argp1 = (Dali::BaseHandle *)jarg1;
24414   if (!argp1) {
24415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24416     return 0;
24417   }
24418   arg1 = *argp1;
24419   {
24420     try {
24421       result = Dali::RenderTaskList::DownCast(arg1);
24422     } catch (std::out_of_range& e) {
24423       {
24424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24425       };
24426     } catch (std::exception& e) {
24427       {
24428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24429       };
24430     } catch (...) {
24431       {
24432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24433       };
24434     }
24435   }
24436   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
24437   return jresult;
24438 }
24439
24440
24441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
24442   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24443
24444   arg1 = (Dali::RenderTaskList *)jarg1;
24445   {
24446     try {
24447       delete arg1;
24448     } catch (std::out_of_range& e) {
24449       {
24450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24451       };
24452     } catch (std::exception& e) {
24453       {
24454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24455       };
24456     } catch (...) {
24457       {
24458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24459       };
24460     }
24461   }
24462 }
24463
24464
24465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
24466   void * jresult ;
24467   Dali::RenderTaskList *arg1 = 0 ;
24468   Dali::RenderTaskList *result = 0 ;
24469
24470   arg1 = (Dali::RenderTaskList *)jarg1;
24471   if (!arg1) {
24472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24473     return 0;
24474   }
24475   {
24476     try {
24477       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
24478     } catch (std::out_of_range& e) {
24479       {
24480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24481       };
24482     } catch (std::exception& e) {
24483       {
24484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24485       };
24486     } catch (...) {
24487       {
24488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24489       };
24490     }
24491   }
24492   jresult = (void *)result;
24493   return jresult;
24494 }
24495
24496
24497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
24498   void * jresult ;
24499   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24500   Dali::RenderTaskList *arg2 = 0 ;
24501   Dali::RenderTaskList *result = 0 ;
24502
24503   arg1 = (Dali::RenderTaskList *)jarg1;
24504   arg2 = (Dali::RenderTaskList *)jarg2;
24505   if (!arg2) {
24506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24507     return 0;
24508   }
24509   {
24510     try {
24511       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
24512     } catch (std::out_of_range& e) {
24513       {
24514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24515       };
24516     } catch (std::exception& e) {
24517       {
24518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24519       };
24520     } catch (...) {
24521       {
24522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24523       };
24524     }
24525   }
24526   jresult = (void *)result;
24527   return jresult;
24528 }
24529
24530
24531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
24532   void * jresult ;
24533   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24534   Dali::RenderTask result;
24535
24536   arg1 = (Dali::RenderTaskList *)jarg1;
24537   {
24538     try {
24539       result = (arg1)->CreateTask();
24540     } catch (std::out_of_range& e) {
24541       {
24542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24543       };
24544     } catch (std::exception& e) {
24545       {
24546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24547       };
24548     } catch (...) {
24549       {
24550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24551       };
24552     }
24553   }
24554   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24555   return jresult;
24556 }
24557
24558
24559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
24560   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24561   Dali::RenderTask arg2 ;
24562   Dali::RenderTask *argp2 ;
24563
24564   arg1 = (Dali::RenderTaskList *)jarg1;
24565   argp2 = (Dali::RenderTask *)jarg2;
24566   if (!argp2) {
24567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
24568     return ;
24569   }
24570   arg2 = *argp2;
24571   {
24572     try {
24573       (arg1)->RemoveTask(arg2);
24574     } catch (std::out_of_range& e) {
24575       {
24576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24577       };
24578     } catch (std::exception& e) {
24579       {
24580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24581       };
24582     } catch (...) {
24583       {
24584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24585       };
24586     }
24587   }
24588 }
24589
24590
24591 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
24592   unsigned int jresult ;
24593   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24594   unsigned int result;
24595
24596   arg1 = (Dali::RenderTaskList *)jarg1;
24597   {
24598     try {
24599       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
24600     } catch (std::out_of_range& e) {
24601       {
24602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24603       };
24604     } catch (std::exception& e) {
24605       {
24606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24607       };
24608     } catch (...) {
24609       {
24610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24611       };
24612     }
24613   }
24614   jresult = result;
24615   return jresult;
24616 }
24617
24618
24619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
24620   void * jresult ;
24621   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24622   unsigned int arg2 ;
24623   Dali::RenderTask result;
24624
24625   arg1 = (Dali::RenderTaskList *)jarg1;
24626   arg2 = (unsigned int)jarg2;
24627   {
24628     try {
24629       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
24630     } catch (std::out_of_range& e) {
24631       {
24632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24633       };
24634     } catch (std::exception& e) {
24635       {
24636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24637       };
24638     } catch (...) {
24639       {
24640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24641       };
24642     }
24643   }
24644   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24645   return jresult;
24646 }
24647
24648
24649 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
24650   int jresult ;
24651   int result;
24652
24653   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
24654   jresult = (int)result;
24655   return jresult;
24656 }
24657
24658
24659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
24660   int jresult ;
24661   int result;
24662
24663   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
24664   jresult = (int)result;
24665   return jresult;
24666 }
24667
24668
24669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
24670   int jresult ;
24671   int result;
24672
24673   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
24674   jresult = (int)result;
24675   return jresult;
24676 }
24677
24678
24679 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
24680   int jresult ;
24681   int result;
24682
24683   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
24684   jresult = (int)result;
24685   return jresult;
24686 }
24687
24688
24689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
24690   void * jresult ;
24691   Dali::RenderTask::Property *result = 0 ;
24692
24693   {
24694     try {
24695       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
24696     } catch (std::out_of_range& e) {
24697       {
24698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24699       };
24700     } catch (std::exception& e) {
24701       {
24702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24703       };
24704     } catch (...) {
24705       {
24706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24707       };
24708     }
24709   }
24710   jresult = (void *)result;
24711   return jresult;
24712 }
24713
24714
24715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
24716   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
24717
24718   arg1 = (Dali::RenderTask::Property *)jarg1;
24719   {
24720     try {
24721       delete arg1;
24722     } catch (std::out_of_range& e) {
24723       {
24724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24725       };
24726     } catch (std::exception& e) {
24727       {
24728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24729       };
24730     } catch (...) {
24731       {
24732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24733       };
24734     }
24735   }
24736 }
24737
24738
24739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
24740   void * jresult ;
24741   bool (*result)(Dali::Vector2 &) = 0 ;
24742
24743   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
24744   jresult = (void *)result;
24745   return jresult;
24746 }
24747
24748
24749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
24750   void * jresult ;
24751   bool (*result)(Dali::Vector2 &) = 0 ;
24752
24753   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
24754   jresult = (void *)result;
24755   return jresult;
24756 }
24757
24758
24759 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
24760   unsigned int jresult ;
24761   bool result;
24762
24763   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
24764   jresult = result;
24765   return jresult;
24766 }
24767
24768
24769 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
24770   unsigned int jresult ;
24771   bool result;
24772
24773   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
24774   jresult = result;
24775   return jresult;
24776 }
24777
24778
24779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
24780   void * jresult ;
24781   Dali::Vector4 *result = 0 ;
24782
24783   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
24784   jresult = (void *)result;
24785   return jresult;
24786 }
24787
24788
24789 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
24790   unsigned int jresult ;
24791   bool result;
24792
24793   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
24794   jresult = result;
24795   return jresult;
24796 }
24797
24798
24799 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
24800   unsigned int jresult ;
24801   bool result;
24802
24803   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
24804   jresult = result;
24805   return jresult;
24806 }
24807
24808
24809 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
24810   unsigned int jresult ;
24811   unsigned int result;
24812
24813   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
24814   jresult = result;
24815   return jresult;
24816 }
24817
24818
24819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
24820   void * jresult ;
24821   Dali::RenderTask *result = 0 ;
24822
24823   {
24824     try {
24825       result = (Dali::RenderTask *)new Dali::RenderTask();
24826     } catch (std::out_of_range& e) {
24827       {
24828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24829       };
24830     } catch (std::exception& e) {
24831       {
24832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24833       };
24834     } catch (...) {
24835       {
24836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24837       };
24838     }
24839   }
24840   jresult = (void *)result;
24841   return jresult;
24842 }
24843
24844
24845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
24846   void * jresult ;
24847   Dali::BaseHandle arg1 ;
24848   Dali::BaseHandle *argp1 ;
24849   Dali::RenderTask result;
24850
24851   argp1 = (Dali::BaseHandle *)jarg1;
24852   if (!argp1) {
24853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24854     return 0;
24855   }
24856   arg1 = *argp1;
24857   {
24858     try {
24859       result = Dali::RenderTask::DownCast(arg1);
24860     } catch (std::out_of_range& e) {
24861       {
24862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24863       };
24864     } catch (std::exception& e) {
24865       {
24866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24867       };
24868     } catch (...) {
24869       {
24870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24871       };
24872     }
24873   }
24874   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24875   return jresult;
24876 }
24877
24878
24879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
24880   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24881
24882   arg1 = (Dali::RenderTask *)jarg1;
24883   {
24884     try {
24885       delete arg1;
24886     } catch (std::out_of_range& e) {
24887       {
24888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24889       };
24890     } catch (std::exception& e) {
24891       {
24892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24893       };
24894     } catch (...) {
24895       {
24896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24897       };
24898     }
24899   }
24900 }
24901
24902
24903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
24904   void * jresult ;
24905   Dali::RenderTask *arg1 = 0 ;
24906   Dali::RenderTask *result = 0 ;
24907
24908   arg1 = (Dali::RenderTask *)jarg1;
24909   if (!arg1) {
24910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24911     return 0;
24912   }
24913   {
24914     try {
24915       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
24916     } catch (std::out_of_range& e) {
24917       {
24918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24919       };
24920     } catch (std::exception& e) {
24921       {
24922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24923       };
24924     } catch (...) {
24925       {
24926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24927       };
24928     }
24929   }
24930   jresult = (void *)result;
24931   return jresult;
24932 }
24933
24934
24935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
24936   void * jresult ;
24937   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24938   Dali::RenderTask *arg2 = 0 ;
24939   Dali::RenderTask *result = 0 ;
24940
24941   arg1 = (Dali::RenderTask *)jarg1;
24942   arg2 = (Dali::RenderTask *)jarg2;
24943   if (!arg2) {
24944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24945     return 0;
24946   }
24947   {
24948     try {
24949       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
24950     } catch (std::out_of_range& e) {
24951       {
24952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24953       };
24954     } catch (std::exception& e) {
24955       {
24956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24957       };
24958     } catch (...) {
24959       {
24960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24961       };
24962     }
24963   }
24964   jresult = (void *)result;
24965   return jresult;
24966 }
24967
24968
24969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
24970   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24971   Dali::Actor arg2 ;
24972   Dali::Actor *argp2 ;
24973
24974   arg1 = (Dali::RenderTask *)jarg1;
24975   argp2 = (Dali::Actor *)jarg2;
24976   if (!argp2) {
24977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24978     return ;
24979   }
24980   arg2 = *argp2;
24981   {
24982     try {
24983       (arg1)->SetSourceActor(arg2);
24984     } catch (std::out_of_range& e) {
24985       {
24986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24987       };
24988     } catch (std::exception& e) {
24989       {
24990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24991       };
24992     } catch (...) {
24993       {
24994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24995       };
24996     }
24997   }
24998 }
24999
25000
25001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
25002   void * jresult ;
25003   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25004   Dali::Actor result;
25005
25006   arg1 = (Dali::RenderTask *)jarg1;
25007   {
25008     try {
25009       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
25010     } catch (std::out_of_range& e) {
25011       {
25012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25013       };
25014     } catch (std::exception& e) {
25015       {
25016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25017       };
25018     } catch (...) {
25019       {
25020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25021       };
25022     }
25023   }
25024   jresult = new Dali::Actor((const Dali::Actor &)result);
25025   return jresult;
25026 }
25027
25028
25029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
25030   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25031   bool arg2 ;
25032
25033   arg1 = (Dali::RenderTask *)jarg1;
25034   arg2 = jarg2 ? true : false;
25035   {
25036     try {
25037       (arg1)->SetExclusive(arg2);
25038     } catch (std::out_of_range& e) {
25039       {
25040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25041       };
25042     } catch (std::exception& e) {
25043       {
25044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25045       };
25046     } catch (...) {
25047       {
25048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25049       };
25050     }
25051   }
25052 }
25053
25054
25055 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
25056   unsigned int jresult ;
25057   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25058   bool result;
25059
25060   arg1 = (Dali::RenderTask *)jarg1;
25061   {
25062     try {
25063       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
25064     } catch (std::out_of_range& e) {
25065       {
25066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25067       };
25068     } catch (std::exception& e) {
25069       {
25070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25071       };
25072     } catch (...) {
25073       {
25074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25075       };
25076     }
25077   }
25078   jresult = result;
25079   return jresult;
25080 }
25081
25082
25083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
25084   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25085   bool arg2 ;
25086
25087   arg1 = (Dali::RenderTask *)jarg1;
25088   arg2 = jarg2 ? true : false;
25089   {
25090     try {
25091       (arg1)->SetInputEnabled(arg2);
25092     } catch (std::out_of_range& e) {
25093       {
25094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25095       };
25096     } catch (std::exception& e) {
25097       {
25098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25099       };
25100     } catch (...) {
25101       {
25102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25103       };
25104     }
25105   }
25106 }
25107
25108
25109 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
25110   unsigned int jresult ;
25111   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25112   bool result;
25113
25114   arg1 = (Dali::RenderTask *)jarg1;
25115   {
25116     try {
25117       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
25118     } catch (std::out_of_range& e) {
25119       {
25120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25121       };
25122     } catch (std::exception& e) {
25123       {
25124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25125       };
25126     } catch (...) {
25127       {
25128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25129       };
25130     }
25131   }
25132   jresult = result;
25133   return jresult;
25134 }
25135
25136
25137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
25138   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25139   Dali::CameraActor arg2 ;
25140   Dali::CameraActor *argp2 ;
25141
25142   arg1 = (Dali::RenderTask *)jarg1;
25143   argp2 = (Dali::CameraActor *)jarg2;
25144   if (!argp2) {
25145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
25146     return ;
25147   }
25148   arg2 = *argp2;
25149   {
25150     try {
25151       (arg1)->SetCameraActor(arg2);
25152     } catch (std::out_of_range& e) {
25153       {
25154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25155       };
25156     } catch (std::exception& e) {
25157       {
25158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25159       };
25160     } catch (...) {
25161       {
25162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25163       };
25164     }
25165   }
25166 }
25167
25168
25169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
25170   void * jresult ;
25171   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25172   Dali::CameraActor result;
25173
25174   arg1 = (Dali::RenderTask *)jarg1;
25175   {
25176     try {
25177       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
25178     } catch (std::out_of_range& e) {
25179       {
25180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25181       };
25182     } catch (std::exception& e) {
25183       {
25184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25185       };
25186     } catch (...) {
25187       {
25188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25189       };
25190     }
25191   }
25192   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
25193   return jresult;
25194 }
25195
25196
25197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
25198   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25199   Dali::FrameBufferImage arg2 ;
25200   Dali::FrameBufferImage *argp2 ;
25201
25202   arg1 = (Dali::RenderTask *)jarg1;
25203   argp2 = (Dali::FrameBufferImage *)jarg2;
25204   if (!argp2) {
25205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
25206     return ;
25207   }
25208   arg2 = *argp2;
25209   {
25210     try {
25211       (arg1)->SetTargetFrameBuffer(arg2);
25212     } catch (std::out_of_range& e) {
25213       {
25214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25215       };
25216     } catch (std::exception& e) {
25217       {
25218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25219       };
25220     } catch (...) {
25221       {
25222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25223       };
25224     }
25225   }
25226 }
25227
25228
25229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
25230   void * jresult ;
25231   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25232   Dali::FrameBufferImage result;
25233
25234   arg1 = (Dali::RenderTask *)jarg1;
25235   {
25236     try {
25237       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
25238     } catch (std::out_of_range& e) {
25239       {
25240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25241       };
25242     } catch (std::exception& e) {
25243       {
25244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25245       };
25246     } catch (...) {
25247       {
25248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25249       };
25250     }
25251   }
25252   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
25253   return jresult;
25254 }
25255
25256
25257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
25258   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25259   Dali::FrameBuffer arg2 ;
25260   Dali::FrameBuffer *argp2 ;
25261
25262   arg1 = (Dali::RenderTask *)jarg1;
25263   argp2 = (Dali::FrameBuffer *)jarg2;
25264   if (!argp2) {
25265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
25266     return ;
25267   }
25268   arg2 = *argp2;
25269   {
25270     try {
25271       (arg1)->SetFrameBuffer(arg2);
25272     } catch (std::out_of_range& e) {
25273       {
25274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25275       };
25276     } catch (std::exception& e) {
25277       {
25278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25279       };
25280     } catch (...) {
25281       {
25282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25283       };
25284     }
25285   }
25286 }
25287
25288
25289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
25290   void * jresult ;
25291   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25292   Dali::FrameBuffer result;
25293
25294   arg1 = (Dali::RenderTask *)jarg1;
25295   {
25296     try {
25297       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
25298     } catch (std::out_of_range& e) {
25299       {
25300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25301       };
25302     } catch (std::exception& e) {
25303       {
25304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25305       };
25306     } catch (...) {
25307       {
25308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25309       };
25310     }
25311   }
25312   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
25313   return jresult;
25314 }
25315
25316
25317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
25318   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25319   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
25320
25321   arg1 = (Dali::RenderTask *)jarg1;
25322   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
25323   {
25324     try {
25325       (arg1)->SetScreenToFrameBufferFunction(arg2);
25326     } catch (std::out_of_range& e) {
25327       {
25328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25329       };
25330     } catch (std::exception& e) {
25331       {
25332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25333       };
25334     } catch (...) {
25335       {
25336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25337       };
25338     }
25339   }
25340 }
25341
25342
25343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
25344   void * jresult ;
25345   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25346   Dali::RenderTask::ScreenToFrameBufferFunction result;
25347
25348   arg1 = (Dali::RenderTask *)jarg1;
25349   {
25350     try {
25351       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
25352     } catch (std::out_of_range& e) {
25353       {
25354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25355       };
25356     } catch (std::exception& e) {
25357       {
25358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25359       };
25360     } catch (...) {
25361       {
25362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25363       };
25364     }
25365   }
25366   jresult = (void *)result;
25367   return jresult;
25368 }
25369
25370
25371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
25372   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25373   Dali::Actor arg2 ;
25374   Dali::Actor *argp2 ;
25375
25376   arg1 = (Dali::RenderTask *)jarg1;
25377   argp2 = (Dali::Actor *)jarg2;
25378   if (!argp2) {
25379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25380     return ;
25381   }
25382   arg2 = *argp2;
25383   {
25384     try {
25385       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
25386     } catch (std::out_of_range& e) {
25387       {
25388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25389       };
25390     } catch (std::exception& e) {
25391       {
25392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25393       };
25394     } catch (...) {
25395       {
25396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25397       };
25398     }
25399   }
25400 }
25401
25402
25403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
25404   void * jresult ;
25405   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25406   Dali::Actor result;
25407
25408   arg1 = (Dali::RenderTask *)jarg1;
25409   {
25410     try {
25411       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
25412     } catch (std::out_of_range& e) {
25413       {
25414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25415       };
25416     } catch (std::exception& e) {
25417       {
25418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25419       };
25420     } catch (...) {
25421       {
25422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25423       };
25424     }
25425   }
25426   jresult = new Dali::Actor((const Dali::Actor &)result);
25427   return jresult;
25428 }
25429
25430
25431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
25432   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25433   Dali::Vector2 arg2 ;
25434   Dali::Vector2 *argp2 ;
25435
25436   arg1 = (Dali::RenderTask *)jarg1;
25437   argp2 = (Dali::Vector2 *)jarg2;
25438   if (!argp2) {
25439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25440     return ;
25441   }
25442   arg2 = *argp2;
25443   {
25444     try {
25445       (arg1)->SetViewportPosition(arg2);
25446     } catch (std::out_of_range& e) {
25447       {
25448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25449       };
25450     } catch (std::exception& e) {
25451       {
25452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25453       };
25454     } catch (...) {
25455       {
25456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25457       };
25458     }
25459   }
25460 }
25461
25462
25463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
25464   void * jresult ;
25465   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25466   Dali::Vector2 result;
25467
25468   arg1 = (Dali::RenderTask *)jarg1;
25469   {
25470     try {
25471       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
25472     } catch (std::out_of_range& e) {
25473       {
25474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25475       };
25476     } catch (std::exception& e) {
25477       {
25478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25479       };
25480     } catch (...) {
25481       {
25482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25483       };
25484     }
25485   }
25486   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25487   return jresult;
25488 }
25489
25490
25491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
25492   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25493   Dali::Vector2 arg2 ;
25494   Dali::Vector2 *argp2 ;
25495
25496   arg1 = (Dali::RenderTask *)jarg1;
25497   argp2 = (Dali::Vector2 *)jarg2;
25498   if (!argp2) {
25499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25500     return ;
25501   }
25502   arg2 = *argp2;
25503   {
25504     try {
25505       (arg1)->SetViewportSize(arg2);
25506     } catch (std::out_of_range& e) {
25507       {
25508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25509       };
25510     } catch (std::exception& e) {
25511       {
25512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25513       };
25514     } catch (...) {
25515       {
25516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25517       };
25518     }
25519   }
25520 }
25521
25522
25523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
25524   void * jresult ;
25525   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25526   Dali::Vector2 result;
25527
25528   arg1 = (Dali::RenderTask *)jarg1;
25529   {
25530     try {
25531       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
25532     } catch (std::out_of_range& e) {
25533       {
25534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25535       };
25536     } catch (std::exception& e) {
25537       {
25538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25539       };
25540     } catch (...) {
25541       {
25542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25543       };
25544     }
25545   }
25546   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25547   return jresult;
25548 }
25549
25550
25551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
25552   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25553   Dali::Viewport arg2 ;
25554   Dali::Viewport *argp2 ;
25555
25556   arg1 = (Dali::RenderTask *)jarg1;
25557   argp2 = (Dali::Viewport *)jarg2;
25558   if (!argp2) {
25559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
25560     return ;
25561   }
25562   arg2 = *argp2;
25563   {
25564     try {
25565       (arg1)->SetViewport(arg2);
25566     } catch (std::out_of_range& e) {
25567       {
25568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25569       };
25570     } catch (std::exception& e) {
25571       {
25572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25573       };
25574     } catch (...) {
25575       {
25576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25577       };
25578     }
25579   }
25580 }
25581
25582
25583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
25584   void * jresult ;
25585   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25586   Dali::Viewport result;
25587
25588   arg1 = (Dali::RenderTask *)jarg1;
25589   {
25590     try {
25591       result = ((Dali::RenderTask const *)arg1)->GetViewport();
25592     } catch (std::out_of_range& e) {
25593       {
25594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25595       };
25596     } catch (std::exception& e) {
25597       {
25598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25599       };
25600     } catch (...) {
25601       {
25602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25603       };
25604     }
25605   }
25606   jresult = new Dali::Viewport((const Dali::Viewport &)result);
25607   return jresult;
25608 }
25609
25610
25611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
25612   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25613   Dali::Vector4 *arg2 = 0 ;
25614
25615   arg1 = (Dali::RenderTask *)jarg1;
25616   arg2 = (Dali::Vector4 *)jarg2;
25617   if (!arg2) {
25618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
25619     return ;
25620   }
25621   {
25622     try {
25623       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
25624     } catch (std::out_of_range& e) {
25625       {
25626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25627       };
25628     } catch (std::exception& e) {
25629       {
25630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25631       };
25632     } catch (...) {
25633       {
25634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25635       };
25636     }
25637   }
25638 }
25639
25640
25641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
25642   void * jresult ;
25643   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25644   Dali::Vector4 result;
25645
25646   arg1 = (Dali::RenderTask *)jarg1;
25647   {
25648     try {
25649       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
25650     } catch (std::out_of_range& e) {
25651       {
25652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25653       };
25654     } catch (std::exception& e) {
25655       {
25656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25657       };
25658     } catch (...) {
25659       {
25660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25661       };
25662     }
25663   }
25664   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
25665   return jresult;
25666 }
25667
25668
25669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
25670   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25671   bool arg2 ;
25672
25673   arg1 = (Dali::RenderTask *)jarg1;
25674   arg2 = jarg2 ? true : false;
25675   {
25676     try {
25677       (arg1)->SetClearEnabled(arg2);
25678     } catch (std::out_of_range& e) {
25679       {
25680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25681       };
25682     } catch (std::exception& e) {
25683       {
25684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25685       };
25686     } catch (...) {
25687       {
25688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25689       };
25690     }
25691   }
25692 }
25693
25694
25695 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
25696   unsigned int jresult ;
25697   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25698   bool result;
25699
25700   arg1 = (Dali::RenderTask *)jarg1;
25701   {
25702     try {
25703       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
25704     } catch (std::out_of_range& e) {
25705       {
25706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25707       };
25708     } catch (std::exception& e) {
25709       {
25710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25711       };
25712     } catch (...) {
25713       {
25714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25715       };
25716     }
25717   }
25718   jresult = result;
25719   return jresult;
25720 }
25721
25722
25723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
25724   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25725   bool arg2 ;
25726
25727   arg1 = (Dali::RenderTask *)jarg1;
25728   arg2 = jarg2 ? true : false;
25729   {
25730     try {
25731       (arg1)->SetCullMode(arg2);
25732     } catch (std::out_of_range& e) {
25733       {
25734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25735       };
25736     } catch (std::exception& e) {
25737       {
25738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25739       };
25740     } catch (...) {
25741       {
25742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25743       };
25744     }
25745   }
25746 }
25747
25748
25749 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
25750   unsigned int jresult ;
25751   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25752   bool result;
25753
25754   arg1 = (Dali::RenderTask *)jarg1;
25755   {
25756     try {
25757       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
25758     } catch (std::out_of_range& e) {
25759       {
25760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25761       };
25762     } catch (std::exception& e) {
25763       {
25764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25765       };
25766     } catch (...) {
25767       {
25768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25769       };
25770     }
25771   }
25772   jresult = result;
25773   return jresult;
25774 }
25775
25776
25777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
25778   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25779   unsigned int arg2 ;
25780
25781   arg1 = (Dali::RenderTask *)jarg1;
25782   arg2 = (unsigned int)jarg2;
25783   {
25784     try {
25785       (arg1)->SetRefreshRate(arg2);
25786     } catch (std::out_of_range& e) {
25787       {
25788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25789       };
25790     } catch (std::exception& e) {
25791       {
25792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25793       };
25794     } catch (...) {
25795       {
25796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25797       };
25798     }
25799   }
25800 }
25801
25802
25803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
25804   unsigned int jresult ;
25805   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25806   unsigned int result;
25807
25808   arg1 = (Dali::RenderTask *)jarg1;
25809   {
25810     try {
25811       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
25812     } catch (std::out_of_range& e) {
25813       {
25814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25815       };
25816     } catch (std::exception& e) {
25817       {
25818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25819       };
25820     } catch (...) {
25821       {
25822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25823       };
25824     }
25825   }
25826   jresult = result;
25827   return jresult;
25828 }
25829
25830
25831 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
25832   unsigned int jresult ;
25833   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25834   Dali::Vector3 *arg2 = 0 ;
25835   float *arg3 = 0 ;
25836   float *arg4 = 0 ;
25837   bool result;
25838
25839   arg1 = (Dali::RenderTask *)jarg1;
25840   arg2 = (Dali::Vector3 *)jarg2;
25841   if (!arg2) {
25842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
25843     return 0;
25844   }
25845   arg3 = (float *)jarg3;
25846   arg4 = (float *)jarg4;
25847   {
25848     try {
25849       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
25850     } catch (std::out_of_range& e) {
25851       {
25852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25853       };
25854     } catch (std::exception& e) {
25855       {
25856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25857       };
25858     } catch (...) {
25859       {
25860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25861       };
25862     }
25863   }
25864   jresult = result;
25865   return jresult;
25866 }
25867
25868
25869 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
25870   unsigned int jresult ;
25871   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25872   Dali::Actor arg2 ;
25873   float arg3 ;
25874   float arg4 ;
25875   float *arg5 = 0 ;
25876   float *arg6 = 0 ;
25877   Dali::Actor *argp2 ;
25878   bool result;
25879
25880   arg1 = (Dali::RenderTask *)jarg1;
25881   argp2 = (Dali::Actor *)jarg2;
25882   if (!argp2) {
25883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25884     return 0;
25885   }
25886   arg2 = *argp2;
25887   arg3 = (float)jarg3;
25888   arg4 = (float)jarg4;
25889   arg5 = (float *)jarg5;
25890   arg6 = (float *)jarg6;
25891   {
25892     try {
25893       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
25894     } catch (std::out_of_range& e) {
25895       {
25896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25897       };
25898     } catch (std::exception& e) {
25899       {
25900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25901       };
25902     } catch (...) {
25903       {
25904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25905       };
25906     }
25907   }
25908   jresult = result;
25909   return jresult;
25910 }
25911
25912
25913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
25914   void * jresult ;
25915   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25916   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
25917
25918   arg1 = (Dali::RenderTask *)jarg1;
25919   {
25920     try {
25921       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
25922     } catch (std::out_of_range& e) {
25923       {
25924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25925       };
25926     } catch (std::exception& e) {
25927       {
25928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25929       };
25930     } catch (...) {
25931       {
25932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25933       };
25934     }
25935   }
25936   jresult = (void *)result;
25937   return jresult;
25938 }
25939
25940
25941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
25942   void * jresult ;
25943   int arg1 ;
25944   Dali::TouchPoint::State arg2 ;
25945   float arg3 ;
25946   float arg4 ;
25947   Dali::TouchPoint *result = 0 ;
25948
25949   arg1 = (int)jarg1;
25950   arg2 = (Dali::TouchPoint::State)jarg2;
25951   arg3 = (float)jarg3;
25952   arg4 = (float)jarg4;
25953   {
25954     try {
25955       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
25956     } catch (std::out_of_range& e) {
25957       {
25958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25959       };
25960     } catch (std::exception& e) {
25961       {
25962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25963       };
25964     } catch (...) {
25965       {
25966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25967       };
25968     }
25969   }
25970   jresult = (void *)result;
25971   return jresult;
25972 }
25973
25974
25975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
25976   void * jresult ;
25977   int arg1 ;
25978   Dali::TouchPoint::State arg2 ;
25979   float arg3 ;
25980   float arg4 ;
25981   float arg5 ;
25982   float arg6 ;
25983   Dali::TouchPoint *result = 0 ;
25984
25985   arg1 = (int)jarg1;
25986   arg2 = (Dali::TouchPoint::State)jarg2;
25987   arg3 = (float)jarg3;
25988   arg4 = (float)jarg4;
25989   arg5 = (float)jarg5;
25990   arg6 = (float)jarg6;
25991   {
25992     try {
25993       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
25994     } catch (std::out_of_range& e) {
25995       {
25996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25997       };
25998     } catch (std::exception& e) {
25999       {
26000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26001       };
26002     } catch (...) {
26003       {
26004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26005       };
26006     }
26007   }
26008   jresult = (void *)result;
26009   return jresult;
26010 }
26011
26012
26013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
26014   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26015
26016   arg1 = (Dali::TouchPoint *)jarg1;
26017   {
26018     try {
26019       delete arg1;
26020     } catch (std::out_of_range& e) {
26021       {
26022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26023       };
26024     } catch (std::exception& e) {
26025       {
26026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26027       };
26028     } catch (...) {
26029       {
26030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26031       };
26032     }
26033   }
26034 }
26035
26036
26037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
26038   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26039   int arg2 ;
26040
26041   arg1 = (Dali::TouchPoint *)jarg1;
26042   arg2 = (int)jarg2;
26043   if (arg1) (arg1)->deviceId = arg2;
26044 }
26045
26046
26047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
26048   int jresult ;
26049   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26050   int result;
26051
26052   arg1 = (Dali::TouchPoint *)jarg1;
26053   result = (int) ((arg1)->deviceId);
26054   jresult = result;
26055   return jresult;
26056 }
26057
26058
26059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
26060   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26061   Dali::TouchPoint::State arg2 ;
26062
26063   arg1 = (Dali::TouchPoint *)jarg1;
26064   arg2 = (Dali::TouchPoint::State)jarg2;
26065   if (arg1) (arg1)->state = arg2;
26066 }
26067
26068
26069 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
26070   int jresult ;
26071   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26072   Dali::TouchPoint::State result;
26073
26074   arg1 = (Dali::TouchPoint *)jarg1;
26075   result = (Dali::TouchPoint::State) ((arg1)->state);
26076   jresult = (int)result;
26077   return jresult;
26078 }
26079
26080
26081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
26082   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26083   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
26084
26085   arg1 = (Dali::TouchPoint *)jarg1;
26086   arg2 = (Dali::Actor *)jarg2;
26087   if (arg1) (arg1)->hitActor = *arg2;
26088 }
26089
26090
26091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
26092   void * jresult ;
26093   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26094   Dali::Actor *result = 0 ;
26095
26096   arg1 = (Dali::TouchPoint *)jarg1;
26097   result = (Dali::Actor *)& ((arg1)->hitActor);
26098   jresult = (void *)result;
26099   return jresult;
26100 }
26101
26102
26103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
26104   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26105   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26106
26107   arg1 = (Dali::TouchPoint *)jarg1;
26108   arg2 = (Dali::Vector2 *)jarg2;
26109   if (arg1) (arg1)->local = *arg2;
26110 }
26111
26112
26113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
26114   void * jresult ;
26115   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26116   Dali::Vector2 *result = 0 ;
26117
26118   arg1 = (Dali::TouchPoint *)jarg1;
26119   result = (Dali::Vector2 *)& ((arg1)->local);
26120   jresult = (void *)result;
26121   return jresult;
26122 }
26123
26124
26125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
26126   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26127   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26128
26129   arg1 = (Dali::TouchPoint *)jarg1;
26130   arg2 = (Dali::Vector2 *)jarg2;
26131   if (arg1) (arg1)->screen = *arg2;
26132 }
26133
26134
26135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
26136   void * jresult ;
26137   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26138   Dali::Vector2 *result = 0 ;
26139
26140   arg1 = (Dali::TouchPoint *)jarg1;
26141   result = (Dali::Vector2 *)& ((arg1)->screen);
26142   jresult = (void *)result;
26143   return jresult;
26144 }
26145
26146
26147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
26148   void * jresult ;
26149   Dali::TouchData *result = 0 ;
26150
26151   {
26152     try {
26153       result = (Dali::TouchData *)new Dali::TouchData();
26154     } catch (std::out_of_range& e) {
26155       {
26156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26157       };
26158     } catch (std::exception& e) {
26159       {
26160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26161       };
26162     } catch (...) {
26163       {
26164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26165       };
26166     }
26167   }
26168   jresult = (void *)result;
26169   return jresult;
26170 }
26171
26172
26173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
26174   void * jresult ;
26175   Dali::TouchData *arg1 = 0 ;
26176   Dali::TouchData *result = 0 ;
26177
26178   arg1 = (Dali::TouchData *)jarg1;
26179   if (!arg1) {
26180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26181     return 0;
26182   }
26183   {
26184     try {
26185       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
26186     } catch (std::out_of_range& e) {
26187       {
26188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26189       };
26190     } catch (std::exception& e) {
26191       {
26192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26193       };
26194     } catch (...) {
26195       {
26196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26197       };
26198     }
26199   }
26200   jresult = (void *)result;
26201   return jresult;
26202 }
26203
26204
26205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
26206   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26207
26208   arg1 = (Dali::TouchData *)jarg1;
26209   {
26210     try {
26211       delete arg1;
26212     } catch (std::out_of_range& e) {
26213       {
26214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26215       };
26216     } catch (std::exception& e) {
26217       {
26218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26219       };
26220     } catch (...) {
26221       {
26222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26223       };
26224     }
26225   }
26226 }
26227
26228
26229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
26230   void * jresult ;
26231   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26232   Dali::TouchData *arg2 = 0 ;
26233   Dali::TouchData *result = 0 ;
26234
26235   arg1 = (Dali::TouchData *)jarg1;
26236   arg2 = (Dali::TouchData *)jarg2;
26237   if (!arg2) {
26238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26239     return 0;
26240   }
26241   {
26242     try {
26243       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
26244     } catch (std::out_of_range& e) {
26245       {
26246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26247       };
26248     } catch (std::exception& e) {
26249       {
26250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26251       };
26252     } catch (...) {
26253       {
26254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26255       };
26256     }
26257   }
26258   jresult = (void *)result;
26259   return jresult;
26260 }
26261
26262
26263 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
26264   unsigned long jresult ;
26265   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26266   unsigned long result;
26267
26268   arg1 = (Dali::TouchData *)jarg1;
26269   {
26270     try {
26271       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
26272     } catch (std::out_of_range& e) {
26273       {
26274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26275       };
26276     } catch (std::exception& e) {
26277       {
26278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26279       };
26280     } catch (...) {
26281       {
26282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26283       };
26284     }
26285   }
26286   jresult = (unsigned long)result;
26287   return jresult;
26288 }
26289
26290
26291 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
26292   unsigned long jresult ;
26293   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26294   std::size_t result;
26295
26296   arg1 = (Dali::TouchData *)jarg1;
26297   {
26298     try {
26299       result = ((Dali::TouchData const *)arg1)->GetPointCount();
26300     } catch (std::out_of_range& e) {
26301       {
26302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26303       };
26304     } catch (std::exception& e) {
26305       {
26306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26307       };
26308     } catch (...) {
26309       {
26310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26311       };
26312     }
26313   }
26314   jresult = (unsigned long)result;
26315   return jresult;
26316 }
26317
26318
26319 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
26320   int jresult ;
26321   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26322   std::size_t arg2 ;
26323   int32_t result;
26324
26325   arg1 = (Dali::TouchData *)jarg1;
26326   arg2 = (std::size_t)jarg2;
26327   {
26328     try {
26329       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
26330     } catch (std::out_of_range& e) {
26331       {
26332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26333       };
26334     } catch (std::exception& e) {
26335       {
26336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26337       };
26338     } catch (...) {
26339       {
26340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26341       };
26342     }
26343   }
26344   jresult = result;
26345   return jresult;
26346 }
26347
26348
26349 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
26350   int jresult ;
26351   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26352   std::size_t arg2 ;
26353   Dali::PointState::Type result;
26354
26355   arg1 = (Dali::TouchData *)jarg1;
26356   arg2 = (std::size_t)jarg2;
26357   {
26358     try {
26359       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
26360     } catch (std::out_of_range& e) {
26361       {
26362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26363       };
26364     } catch (std::exception& e) {
26365       {
26366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26367       };
26368     } catch (...) {
26369       {
26370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26371       };
26372     }
26373   }
26374   jresult = (int)result;
26375   return jresult;
26376 }
26377
26378
26379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
26380   void * jresult ;
26381   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26382   std::size_t arg2 ;
26383   Dali::Actor result;
26384
26385   arg1 = (Dali::TouchData *)jarg1;
26386   arg2 = (std::size_t)jarg2;
26387   {
26388     try {
26389       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
26390     } catch (std::out_of_range& e) {
26391       {
26392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26393       };
26394     } catch (std::exception& e) {
26395       {
26396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26397       };
26398     } catch (...) {
26399       {
26400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26401       };
26402     }
26403   }
26404   jresult = new Dali::Actor((const Dali::Actor &)result);
26405   return jresult;
26406 }
26407
26408
26409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
26410   void * jresult ;
26411   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26412   std::size_t arg2 ;
26413   Dali::Vector2 *result = 0 ;
26414
26415   arg1 = (Dali::TouchData *)jarg1;
26416   arg2 = (std::size_t)jarg2;
26417   {
26418     try {
26419       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
26420     } catch (std::out_of_range& e) {
26421       {
26422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26423       };
26424     } catch (std::exception& e) {
26425       {
26426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26427       };
26428     } catch (...) {
26429       {
26430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26431       };
26432     }
26433   }
26434   jresult = (void *)result;
26435   return jresult;
26436 }
26437
26438
26439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
26440   void * jresult ;
26441   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26442   std::size_t arg2 ;
26443   Dali::Vector2 *result = 0 ;
26444
26445   arg1 = (Dali::TouchData *)jarg1;
26446   arg2 = (std::size_t)jarg2;
26447   {
26448     try {
26449       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
26450     } catch (std::out_of_range& e) {
26451       {
26452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26453       };
26454     } catch (std::exception& e) {
26455       {
26456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26457       };
26458     } catch (...) {
26459       {
26460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26461       };
26462     }
26463   }
26464   jresult = (void *)result;
26465   return jresult;
26466 }
26467
26468
26469 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
26470   float jresult ;
26471   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26472   std::size_t arg2 ;
26473   float result;
26474
26475   arg1 = (Dali::TouchData *)jarg1;
26476   arg2 = (std::size_t)jarg2;
26477   {
26478     try {
26479       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
26480     } catch (std::out_of_range& e) {
26481       {
26482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26483       };
26484     } catch (std::exception& e) {
26485       {
26486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26487       };
26488     } catch (...) {
26489       {
26490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26491       };
26492     }
26493   }
26494   jresult = result;
26495   return jresult;
26496 }
26497
26498
26499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
26500   void * jresult ;
26501   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26502   std::size_t arg2 ;
26503   Dali::Vector2 *result = 0 ;
26504
26505   arg1 = (Dali::TouchData *)jarg1;
26506   arg2 = (std::size_t)jarg2;
26507   {
26508     try {
26509       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
26510     } catch (std::out_of_range& e) {
26511       {
26512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26513       };
26514     } catch (std::exception& e) {
26515       {
26516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26517       };
26518     } catch (...) {
26519       {
26520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26521       };
26522     }
26523   }
26524   jresult = (void *)result;
26525   return jresult;
26526 }
26527
26528
26529 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
26530   float jresult ;
26531   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26532   std::size_t arg2 ;
26533   float result;
26534
26535   arg1 = (Dali::TouchData *)jarg1;
26536   arg2 = (std::size_t)jarg2;
26537   {
26538     try {
26539       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
26540     } catch (std::out_of_range& e) {
26541       {
26542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26543       };
26544     } catch (std::exception& e) {
26545       {
26546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26547       };
26548     } catch (...) {
26549       {
26550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26551       };
26552     }
26553   }
26554   jresult = result;
26555   return jresult;
26556 }
26557
26558
26559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
26560   void * jresult ;
26561   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26562   std::size_t arg2 ;
26563   Dali::Degree result;
26564
26565   arg1 = (Dali::TouchData *)jarg1;
26566   arg2 = (std::size_t)jarg2;
26567   {
26568     try {
26569       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
26570     } catch (std::out_of_range& e) {
26571       {
26572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26573       };
26574     } catch (std::exception& e) {
26575       {
26576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26577       };
26578     } catch (...) {
26579       {
26580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26581       };
26582     }
26583   }
26584   jresult = new Dali::Degree((const Dali::Degree &)result);
26585   return jresult;
26586 }
26587
26588
26589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
26590   void * jresult ;
26591   Dali::GestureDetector *result = 0 ;
26592
26593   {
26594     try {
26595       result = (Dali::GestureDetector *)new Dali::GestureDetector();
26596     } catch (std::out_of_range& e) {
26597       {
26598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26599       };
26600     } catch (std::exception& e) {
26601       {
26602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26603       };
26604     } catch (...) {
26605       {
26606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26607       };
26608     }
26609   }
26610   jresult = (void *)result;
26611   return jresult;
26612 }
26613
26614
26615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
26616   void * jresult ;
26617   Dali::BaseHandle arg1 ;
26618   Dali::BaseHandle *argp1 ;
26619   Dali::GestureDetector result;
26620
26621   argp1 = (Dali::BaseHandle *)jarg1;
26622   if (!argp1) {
26623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26624     return 0;
26625   }
26626   arg1 = *argp1;
26627   {
26628     try {
26629       result = Dali::GestureDetector::DownCast(arg1);
26630     } catch (std::out_of_range& e) {
26631       {
26632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26633       };
26634     } catch (std::exception& e) {
26635       {
26636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26637       };
26638     } catch (...) {
26639       {
26640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26641       };
26642     }
26643   }
26644   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
26645   return jresult;
26646 }
26647
26648
26649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
26650   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26651
26652   arg1 = (Dali::GestureDetector *)jarg1;
26653   {
26654     try {
26655       delete arg1;
26656     } catch (std::out_of_range& e) {
26657       {
26658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26659       };
26660     } catch (std::exception& e) {
26661       {
26662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26663       };
26664     } catch (...) {
26665       {
26666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26667       };
26668     }
26669   }
26670 }
26671
26672
26673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
26674   void * jresult ;
26675   Dali::GestureDetector *arg1 = 0 ;
26676   Dali::GestureDetector *result = 0 ;
26677
26678   arg1 = (Dali::GestureDetector *)jarg1;
26679   if (!arg1) {
26680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26681     return 0;
26682   }
26683   {
26684     try {
26685       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
26686     } catch (std::out_of_range& e) {
26687       {
26688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26689       };
26690     } catch (std::exception& e) {
26691       {
26692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26693       };
26694     } catch (...) {
26695       {
26696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26697       };
26698     }
26699   }
26700   jresult = (void *)result;
26701   return jresult;
26702 }
26703
26704
26705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
26706   void * jresult ;
26707   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26708   Dali::GestureDetector *arg2 = 0 ;
26709   Dali::GestureDetector *result = 0 ;
26710
26711   arg1 = (Dali::GestureDetector *)jarg1;
26712   arg2 = (Dali::GestureDetector *)jarg2;
26713   if (!arg2) {
26714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26715     return 0;
26716   }
26717   {
26718     try {
26719       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
26720     } catch (std::out_of_range& e) {
26721       {
26722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26723       };
26724     } catch (std::exception& e) {
26725       {
26726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26727       };
26728     } catch (...) {
26729       {
26730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26731       };
26732     }
26733   }
26734   jresult = (void *)result;
26735   return jresult;
26736 }
26737
26738
26739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
26740   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26741   Dali::Actor arg2 ;
26742   Dali::Actor *argp2 ;
26743
26744   arg1 = (Dali::GestureDetector *)jarg1;
26745   argp2 = (Dali::Actor *)jarg2;
26746   if (!argp2) {
26747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26748     return ;
26749   }
26750   arg2 = *argp2;
26751   {
26752     try {
26753       (arg1)->Attach(arg2);
26754     } catch (std::out_of_range& e) {
26755       {
26756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26757       };
26758     } catch (std::exception& e) {
26759       {
26760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26761       };
26762     } catch (...) {
26763       {
26764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26765       };
26766     }
26767   }
26768 }
26769
26770
26771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
26772   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26773   Dali::Actor arg2 ;
26774   Dali::Actor *argp2 ;
26775
26776   arg1 = (Dali::GestureDetector *)jarg1;
26777   argp2 = (Dali::Actor *)jarg2;
26778   if (!argp2) {
26779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26780     return ;
26781   }
26782   arg2 = *argp2;
26783   {
26784     try {
26785       (arg1)->Detach(arg2);
26786     } catch (std::out_of_range& e) {
26787       {
26788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26789       };
26790     } catch (std::exception& e) {
26791       {
26792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26793       };
26794     } catch (...) {
26795       {
26796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26797       };
26798     }
26799   }
26800 }
26801
26802
26803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
26804   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26805
26806   arg1 = (Dali::GestureDetector *)jarg1;
26807   {
26808     try {
26809       (arg1)->DetachAll();
26810     } catch (std::out_of_range& e) {
26811       {
26812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26813       };
26814     } catch (std::exception& e) {
26815       {
26816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26817       };
26818     } catch (...) {
26819       {
26820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26821       };
26822     }
26823   }
26824 }
26825
26826
26827 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
26828   unsigned long jresult ;
26829   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26830   size_t result;
26831
26832   arg1 = (Dali::GestureDetector *)jarg1;
26833   {
26834     try {
26835       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
26836     } catch (std::out_of_range& e) {
26837       {
26838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26839       };
26840     } catch (std::exception& e) {
26841       {
26842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26843       };
26844     } catch (...) {
26845       {
26846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26847       };
26848     }
26849   }
26850   jresult = (unsigned long)result;
26851   return jresult;
26852 }
26853
26854
26855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
26856   void * jresult ;
26857   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26858   size_t arg2 ;
26859   Dali::Actor result;
26860
26861   arg1 = (Dali::GestureDetector *)jarg1;
26862   arg2 = (size_t)jarg2;
26863   {
26864     try {
26865       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
26866     } catch (std::out_of_range& e) {
26867       {
26868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26869       };
26870     } catch (std::exception& e) {
26871       {
26872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26873       };
26874     } catch (...) {
26875       {
26876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26877       };
26878     }
26879   }
26880   jresult = new Dali::Actor((const Dali::Actor &)result);
26881   return jresult;
26882 }
26883
26884
26885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
26886   void * jresult ;
26887   Dali::Gesture *arg1 = 0 ;
26888   Dali::Gesture *result = 0 ;
26889
26890   arg1 = (Dali::Gesture *)jarg1;
26891   if (!arg1) {
26892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26893     return 0;
26894   }
26895   {
26896     try {
26897       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
26898     } catch (std::out_of_range& e) {
26899       {
26900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26901       };
26902     } catch (std::exception& e) {
26903       {
26904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26905       };
26906     } catch (...) {
26907       {
26908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26909       };
26910     }
26911   }
26912   jresult = (void *)result;
26913   return jresult;
26914 }
26915
26916
26917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
26918   void * jresult ;
26919   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26920   Dali::Gesture *arg2 = 0 ;
26921   Dali::Gesture *result = 0 ;
26922
26923   arg1 = (Dali::Gesture *)jarg1;
26924   arg2 = (Dali::Gesture *)jarg2;
26925   if (!arg2) {
26926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26927     return 0;
26928   }
26929   {
26930     try {
26931       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
26932     } catch (std::out_of_range& e) {
26933       {
26934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26935       };
26936     } catch (std::exception& e) {
26937       {
26938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26939       };
26940     } catch (...) {
26941       {
26942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26943       };
26944     }
26945   }
26946   jresult = (void *)result;
26947   return jresult;
26948 }
26949
26950
26951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
26952   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26953
26954   arg1 = (Dali::Gesture *)jarg1;
26955   {
26956     try {
26957       delete arg1;
26958     } catch (std::out_of_range& e) {
26959       {
26960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26961       };
26962     } catch (std::exception& e) {
26963       {
26964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26965       };
26966     } catch (...) {
26967       {
26968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26969       };
26970     }
26971   }
26972 }
26973
26974
26975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
26976   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26977   Dali::Gesture::Type arg2 ;
26978
26979   arg1 = (Dali::Gesture *)jarg1;
26980   arg2 = (Dali::Gesture::Type)jarg2;
26981   if (arg1) (arg1)->type = arg2;
26982 }
26983
26984
26985 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
26986   int jresult ;
26987   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26988   Dali::Gesture::Type result;
26989
26990   arg1 = (Dali::Gesture *)jarg1;
26991   result = (Dali::Gesture::Type) ((arg1)->type);
26992   jresult = (int)result;
26993   return jresult;
26994 }
26995
26996
26997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
26998   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26999   Dali::Gesture::State arg2 ;
27000
27001   arg1 = (Dali::Gesture *)jarg1;
27002   arg2 = (Dali::Gesture::State)jarg2;
27003   if (arg1) (arg1)->state = arg2;
27004 }
27005
27006
27007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
27008   int jresult ;
27009   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
27010   Dali::Gesture::State result;
27011
27012   arg1 = (Dali::Gesture *)jarg1;
27013   result = (Dali::Gesture::State) ((arg1)->state);
27014   jresult = (int)result;
27015   return jresult;
27016 }
27017
27018
27019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
27020   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
27021   unsigned int arg2 ;
27022
27023   arg1 = (Dali::Gesture *)jarg1;
27024   arg2 = (unsigned int)jarg2;
27025   if (arg1) (arg1)->time = arg2;
27026 }
27027
27028
27029 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
27030   unsigned int jresult ;
27031   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
27032   unsigned int result;
27033
27034   arg1 = (Dali::Gesture *)jarg1;
27035   result = (unsigned int) ((arg1)->time);
27036   jresult = result;
27037   return jresult;
27038 }
27039
27040
27041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
27042   void * jresult ;
27043   Dali::HoverEvent *result = 0 ;
27044
27045   {
27046     try {
27047       result = (Dali::HoverEvent *)new Dali::HoverEvent();
27048     } catch (std::out_of_range& e) {
27049       {
27050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27051       };
27052     } catch (std::exception& e) {
27053       {
27054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27055       };
27056     } catch (...) {
27057       {
27058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27059       };
27060     }
27061   }
27062   jresult = (void *)result;
27063   return jresult;
27064 }
27065
27066
27067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
27068   void * jresult ;
27069   unsigned long arg1 ;
27070   Dali::HoverEvent *result = 0 ;
27071
27072   arg1 = (unsigned long)jarg1;
27073   {
27074     try {
27075       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
27076     } catch (std::out_of_range& e) {
27077       {
27078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27079       };
27080     } catch (std::exception& e) {
27081       {
27082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27083       };
27084     } catch (...) {
27085       {
27086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27087       };
27088     }
27089   }
27090   jresult = (void *)result;
27091   return jresult;
27092 }
27093
27094
27095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
27096   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27097
27098   arg1 = (Dali::HoverEvent *)jarg1;
27099   {
27100     try {
27101       delete arg1;
27102     } catch (std::out_of_range& e) {
27103       {
27104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27105       };
27106     } catch (std::exception& e) {
27107       {
27108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27109       };
27110     } catch (...) {
27111       {
27112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27113       };
27114     }
27115   }
27116 }
27117
27118
27119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
27120   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27121   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
27122
27123   arg1 = (Dali::HoverEvent *)jarg1;
27124   arg2 = (Dali::TouchPointContainer *)jarg2;
27125   if (arg1) (arg1)->points = *arg2;
27126 }
27127
27128
27129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
27130   void * jresult ;
27131   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27132   Dali::TouchPointContainer *result = 0 ;
27133
27134   arg1 = (Dali::HoverEvent *)jarg1;
27135   result = (Dali::TouchPointContainer *)& ((arg1)->points);
27136   jresult = (void *)result;
27137   return jresult;
27138 }
27139
27140
27141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
27142   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27143   unsigned long arg2 ;
27144
27145   arg1 = (Dali::HoverEvent *)jarg1;
27146   arg2 = (unsigned long)jarg2;
27147   if (arg1) (arg1)->time = arg2;
27148 }
27149
27150
27151 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
27152   unsigned long jresult ;
27153   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27154   unsigned long result;
27155
27156   arg1 = (Dali::HoverEvent *)jarg1;
27157   result = (unsigned long) ((arg1)->time);
27158   jresult = (unsigned long)result;
27159   return jresult;
27160 }
27161
27162
27163 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
27164   unsigned int jresult ;
27165   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27166   unsigned int result;
27167
27168   arg1 = (Dali::HoverEvent *)jarg1;
27169   {
27170     try {
27171       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
27172     } catch (std::out_of_range& e) {
27173       {
27174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27175       };
27176     } catch (std::exception& e) {
27177       {
27178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27179       };
27180     } catch (...) {
27181       {
27182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27183       };
27184     }
27185   }
27186   jresult = result;
27187   return jresult;
27188 }
27189
27190
27191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
27192   void * jresult ;
27193   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27194   unsigned int arg2 ;
27195   Dali::TouchPoint *result = 0 ;
27196
27197   arg1 = (Dali::HoverEvent *)jarg1;
27198   arg2 = (unsigned int)jarg2;
27199   {
27200     try {
27201       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
27202     } catch (std::out_of_range& e) {
27203       {
27204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27205       };
27206     } catch (std::exception& e) {
27207       {
27208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27209       };
27210     } catch (...) {
27211       {
27212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27213       };
27214     }
27215   }
27216   jresult = (void *)result;
27217   return jresult;
27218 }
27219
27220
27221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
27222   void * jresult ;
27223   Dali::KeyEvent *result = 0 ;
27224
27225   {
27226     try {
27227       result = (Dali::KeyEvent *)new Dali::KeyEvent();
27228     } catch (std::out_of_range& e) {
27229       {
27230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27231       };
27232     } catch (std::exception& e) {
27233       {
27234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27235       };
27236     } catch (...) {
27237       {
27238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27239       };
27240     }
27241   }
27242   jresult = (void *)result;
27243   return jresult;
27244 }
27245
27246
27247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
27248   void * jresult ;
27249   std::string *arg1 = 0 ;
27250   std::string *arg2 = 0 ;
27251   int arg3 ;
27252   int arg4 ;
27253   unsigned long arg5 ;
27254   Dali::KeyEvent::State *arg6 = 0 ;
27255   Dali::KeyEvent::State temp6 ;
27256   Dali::KeyEvent *result = 0 ;
27257
27258   if (!jarg1) {
27259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27260     return 0;
27261   }
27262   std::string arg1_str(jarg1);
27263   arg1 = &arg1_str;
27264   if (!jarg2) {
27265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27266     return 0;
27267   }
27268   std::string arg2_str(jarg2);
27269   arg2 = &arg2_str;
27270   arg3 = (int)jarg3;
27271   arg4 = (int)jarg4;
27272   arg5 = (unsigned long)jarg5;
27273   temp6 = (Dali::KeyEvent::State)jarg6;
27274   arg6 = &temp6;
27275   {
27276     try {
27277       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
27278     } catch (std::out_of_range& e) {
27279       {
27280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27281       };
27282     } catch (std::exception& e) {
27283       {
27284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27285       };
27286     } catch (...) {
27287       {
27288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27289       };
27290     }
27291   }
27292   jresult = (void *)result;
27293
27294   //argout typemap for const std::string&
27295
27296
27297   //argout typemap for const std::string&
27298
27299   return jresult;
27300 }
27301
27302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
27303   void * jresult ;
27304   Dali::KeyEvent *arg1 = 0 ;
27305   Dali::KeyEvent *result = 0 ;
27306
27307   arg1 = (Dali::KeyEvent *)jarg1;
27308   if (!arg1) {
27309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
27310     return 0;
27311   }
27312   {
27313     try {
27314       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
27315     } catch (std::out_of_range& e) {
27316       {
27317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27318       };
27319     } catch (std::exception& e) {
27320       {
27321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27322       };
27323     } catch (...) {
27324       {
27325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27326       };
27327     }
27328   }
27329   jresult = (void *)result;
27330   return jresult;
27331 }
27332
27333
27334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
27335   void * jresult ;
27336   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27337   Dali::KeyEvent *arg2 = 0 ;
27338   Dali::KeyEvent *result = 0 ;
27339
27340   arg1 = (Dali::KeyEvent *)jarg1;
27341   arg2 = (Dali::KeyEvent *)jarg2;
27342   if (!arg2) {
27343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
27344     return 0;
27345   }
27346   {
27347     try {
27348       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
27349     } catch (std::out_of_range& e) {
27350       {
27351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27352       };
27353     } catch (std::exception& e) {
27354       {
27355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27356       };
27357     } catch (...) {
27358       {
27359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27360       };
27361     }
27362   }
27363   jresult = (void *)result;
27364   return jresult;
27365 }
27366
27367
27368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
27369   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27370
27371   arg1 = (Dali::KeyEvent *)jarg1;
27372   {
27373     try {
27374       delete arg1;
27375     } catch (std::out_of_range& e) {
27376       {
27377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27378       };
27379     } catch (std::exception& e) {
27380       {
27381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27382       };
27383     } catch (...) {
27384       {
27385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27386       };
27387     }
27388   }
27389 }
27390
27391
27392 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
27393   unsigned int jresult ;
27394   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27395   bool result;
27396
27397   arg1 = (Dali::KeyEvent *)jarg1;
27398   {
27399     try {
27400       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
27401     } catch (std::out_of_range& e) {
27402       {
27403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27404       };
27405     } catch (std::exception& e) {
27406       {
27407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27408       };
27409     } catch (...) {
27410       {
27411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27412       };
27413     }
27414   }
27415   jresult = result;
27416   return jresult;
27417 }
27418
27419
27420 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
27421   unsigned int jresult ;
27422   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27423   bool result;
27424
27425   arg1 = (Dali::KeyEvent *)jarg1;
27426   {
27427     try {
27428       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
27429     } catch (std::out_of_range& e) {
27430       {
27431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27432       };
27433     } catch (std::exception& e) {
27434       {
27435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27436       };
27437     } catch (...) {
27438       {
27439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27440       };
27441     }
27442   }
27443   jresult = result;
27444   return jresult;
27445 }
27446
27447
27448 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
27449   unsigned int jresult ;
27450   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27451   bool result;
27452
27453   arg1 = (Dali::KeyEvent *)jarg1;
27454   {
27455     try {
27456       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
27457     } catch (std::out_of_range& e) {
27458       {
27459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27460       };
27461     } catch (std::exception& e) {
27462       {
27463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27464       };
27465     } catch (...) {
27466       {
27467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27468       };
27469     }
27470   }
27471   jresult = result;
27472   return jresult;
27473 }
27474
27475
27476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
27477   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27478   std::string *arg2 = 0 ;
27479
27480   arg1 = (Dali::KeyEvent *)jarg1;
27481   if (!jarg2) {
27482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27483     return ;
27484   }
27485   std::string arg2_str(jarg2);
27486   arg2 = &arg2_str;
27487   if (arg1) (arg1)->keyPressedName = *arg2;
27488
27489   //argout typemap for const std::string&
27490
27491 }
27492
27493
27494 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
27495   char * jresult ;
27496   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27497   std::string *result = 0 ;
27498
27499   arg1 = (Dali::KeyEvent *)jarg1;
27500   result = (std::string *) & ((arg1)->keyPressedName);
27501   jresult = SWIG_csharp_string_callback(result->c_str());
27502   return jresult;
27503 }
27504
27505
27506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
27507   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27508   std::string *arg2 = 0 ;
27509
27510   arg1 = (Dali::KeyEvent *)jarg1;
27511   if (!jarg2) {
27512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27513     return ;
27514   }
27515   std::string arg2_str(jarg2);
27516   arg2 = &arg2_str;
27517   if (arg1) (arg1)->keyPressed = *arg2;
27518
27519   //argout typemap for const std::string&
27520
27521 }
27522
27523
27524 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
27525   char * jresult ;
27526   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27527   std::string *result = 0 ;
27528
27529   arg1 = (Dali::KeyEvent *)jarg1;
27530   result = (std::string *) & ((arg1)->keyPressed);
27531   jresult = SWIG_csharp_string_callback(result->c_str());
27532   return jresult;
27533 }
27534
27535
27536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
27537   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27538   int arg2 ;
27539
27540   arg1 = (Dali::KeyEvent *)jarg1;
27541   arg2 = (int)jarg2;
27542   if (arg1) (arg1)->keyCode = arg2;
27543 }
27544
27545
27546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
27547   int jresult ;
27548   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27549   int result;
27550
27551   arg1 = (Dali::KeyEvent *)jarg1;
27552   result = (int) ((arg1)->keyCode);
27553   jresult = result;
27554   return jresult;
27555 }
27556
27557
27558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
27559   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27560   int arg2 ;
27561
27562   arg1 = (Dali::KeyEvent *)jarg1;
27563   arg2 = (int)jarg2;
27564   if (arg1) (arg1)->keyModifier = arg2;
27565 }
27566
27567
27568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
27569   int jresult ;
27570   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27571   int result;
27572
27573   arg1 = (Dali::KeyEvent *)jarg1;
27574   result = (int) ((arg1)->keyModifier);
27575   jresult = result;
27576   return jresult;
27577 }
27578
27579
27580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
27581   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27582   unsigned long arg2 ;
27583
27584   arg1 = (Dali::KeyEvent *)jarg1;
27585   arg2 = (unsigned long)jarg2;
27586   if (arg1) (arg1)->time = arg2;
27587 }
27588
27589
27590 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
27591   unsigned long jresult ;
27592   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27593   unsigned long result;
27594
27595   arg1 = (Dali::KeyEvent *)jarg1;
27596   result = (unsigned long) ((arg1)->time);
27597   jresult = (unsigned long)result;
27598   return jresult;
27599 }
27600
27601
27602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
27603   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27604   Dali::KeyEvent::State arg2 ;
27605
27606   arg1 = (Dali::KeyEvent *)jarg1;
27607   arg2 = (Dali::KeyEvent::State)jarg2;
27608   if (arg1) (arg1)->state = arg2;
27609 }
27610
27611
27612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
27613   int jresult ;
27614   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27615   Dali::KeyEvent::State result;
27616
27617   arg1 = (Dali::KeyEvent *)jarg1;
27618   result = (Dali::KeyEvent::State) ((arg1)->state);
27619   jresult = (int)result;
27620   return jresult;
27621 }
27622
27623
27624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
27625   void * jresult ;
27626   Dali::LongPressGestureDetector *result = 0 ;
27627
27628   {
27629     try {
27630       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
27631     } catch (std::out_of_range& e) {
27632       {
27633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27634       };
27635     } catch (std::exception& e) {
27636       {
27637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27638       };
27639     } catch (...) {
27640       {
27641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27642       };
27643     }
27644   }
27645   jresult = (void *)result;
27646   return jresult;
27647 }
27648
27649
27650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
27651   void * jresult ;
27652   Dali::LongPressGestureDetector result;
27653
27654   {
27655     try {
27656       result = Dali::LongPressGestureDetector::New();
27657     } catch (std::out_of_range& e) {
27658       {
27659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27660       };
27661     } catch (std::exception& e) {
27662       {
27663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27664       };
27665     } catch (...) {
27666       {
27667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27668       };
27669     }
27670   }
27671   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27672   return jresult;
27673 }
27674
27675
27676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
27677   void * jresult ;
27678   unsigned int arg1 ;
27679   Dali::LongPressGestureDetector result;
27680
27681   arg1 = (unsigned int)jarg1;
27682   {
27683     try {
27684       result = Dali::LongPressGestureDetector::New(arg1);
27685     } catch (std::out_of_range& e) {
27686       {
27687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27688       };
27689     } catch (std::exception& e) {
27690       {
27691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27692       };
27693     } catch (...) {
27694       {
27695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27696       };
27697     }
27698   }
27699   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27700   return jresult;
27701 }
27702
27703
27704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
27705   void * jresult ;
27706   unsigned int arg1 ;
27707   unsigned int arg2 ;
27708   Dali::LongPressGestureDetector result;
27709
27710   arg1 = (unsigned int)jarg1;
27711   arg2 = (unsigned int)jarg2;
27712   {
27713     try {
27714       result = Dali::LongPressGestureDetector::New(arg1,arg2);
27715     } catch (std::out_of_range& e) {
27716       {
27717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27718       };
27719     } catch (std::exception& e) {
27720       {
27721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27722       };
27723     } catch (...) {
27724       {
27725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27726       };
27727     }
27728   }
27729   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27730   return jresult;
27731 }
27732
27733
27734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
27735   void * jresult ;
27736   Dali::BaseHandle arg1 ;
27737   Dali::BaseHandle *argp1 ;
27738   Dali::LongPressGestureDetector result;
27739
27740   argp1 = (Dali::BaseHandle *)jarg1;
27741   if (!argp1) {
27742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27743     return 0;
27744   }
27745   arg1 = *argp1;
27746   {
27747     try {
27748       result = Dali::LongPressGestureDetector::DownCast(arg1);
27749     } catch (std::out_of_range& e) {
27750       {
27751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27752       };
27753     } catch (std::exception& e) {
27754       {
27755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27756       };
27757     } catch (...) {
27758       {
27759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27760       };
27761     }
27762   }
27763   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27764   return jresult;
27765 }
27766
27767
27768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
27769   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27770
27771   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27772   {
27773     try {
27774       delete arg1;
27775     } catch (std::out_of_range& e) {
27776       {
27777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27778       };
27779     } catch (std::exception& e) {
27780       {
27781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27782       };
27783     } catch (...) {
27784       {
27785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27786       };
27787     }
27788   }
27789 }
27790
27791
27792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
27793   void * jresult ;
27794   Dali::LongPressGestureDetector *arg1 = 0 ;
27795   Dali::LongPressGestureDetector *result = 0 ;
27796
27797   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27798   if (!arg1) {
27799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27800     return 0;
27801   }
27802   {
27803     try {
27804       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
27805     } catch (std::out_of_range& e) {
27806       {
27807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27808       };
27809     } catch (std::exception& e) {
27810       {
27811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27812       };
27813     } catch (...) {
27814       {
27815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27816       };
27817     }
27818   }
27819   jresult = (void *)result;
27820   return jresult;
27821 }
27822
27823
27824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
27825   void * jresult ;
27826   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27827   Dali::LongPressGestureDetector *arg2 = 0 ;
27828   Dali::LongPressGestureDetector *result = 0 ;
27829
27830   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27831   arg2 = (Dali::LongPressGestureDetector *)jarg2;
27832   if (!arg2) {
27833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27834     return 0;
27835   }
27836   {
27837     try {
27838       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
27839     } catch (std::out_of_range& e) {
27840       {
27841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27842       };
27843     } catch (std::exception& e) {
27844       {
27845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27846       };
27847     } catch (...) {
27848       {
27849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27850       };
27851     }
27852   }
27853   jresult = (void *)result;
27854   return jresult;
27855 }
27856
27857
27858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
27859   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27860   unsigned int arg2 ;
27861
27862   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27863   arg2 = (unsigned int)jarg2;
27864   {
27865     try {
27866       (arg1)->SetTouchesRequired(arg2);
27867     } catch (std::out_of_range& e) {
27868       {
27869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27870       };
27871     } catch (std::exception& e) {
27872       {
27873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27874       };
27875     } catch (...) {
27876       {
27877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27878       };
27879     }
27880   }
27881 }
27882
27883
27884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
27885   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27886   unsigned int arg2 ;
27887   unsigned int arg3 ;
27888
27889   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27890   arg2 = (unsigned int)jarg2;
27891   arg3 = (unsigned int)jarg3;
27892   {
27893     try {
27894       (arg1)->SetTouchesRequired(arg2,arg3);
27895     } catch (std::out_of_range& e) {
27896       {
27897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27898       };
27899     } catch (std::exception& e) {
27900       {
27901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27902       };
27903     } catch (...) {
27904       {
27905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27906       };
27907     }
27908   }
27909 }
27910
27911
27912 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
27913   unsigned int jresult ;
27914   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27915   unsigned int result;
27916
27917   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27918   {
27919     try {
27920       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
27921     } catch (std::out_of_range& e) {
27922       {
27923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27924       };
27925     } catch (std::exception& e) {
27926       {
27927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27928       };
27929     } catch (...) {
27930       {
27931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27932       };
27933     }
27934   }
27935   jresult = result;
27936   return jresult;
27937 }
27938
27939
27940 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
27941   unsigned int jresult ;
27942   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27943   unsigned int result;
27944
27945   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27946   {
27947     try {
27948       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
27949     } catch (std::out_of_range& e) {
27950       {
27951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27952       };
27953     } catch (std::exception& e) {
27954       {
27955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27956       };
27957     } catch (...) {
27958       {
27959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27960       };
27961     }
27962   }
27963   jresult = result;
27964   return jresult;
27965 }
27966
27967
27968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
27969   void * jresult ;
27970   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27971   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
27972
27973   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27974   {
27975     try {
27976       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
27977     } catch (std::out_of_range& e) {
27978       {
27979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27980       };
27981     } catch (std::exception& e) {
27982       {
27983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27984       };
27985     } catch (...) {
27986       {
27987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27988       };
27989     }
27990   }
27991   jresult = (void *)result;
27992   return jresult;
27993 }
27994
27995
27996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
27997   void * jresult ;
27998   Dali::Gesture::State arg1 ;
27999   Dali::LongPressGesture *result = 0 ;
28000
28001   arg1 = (Dali::Gesture::State)jarg1;
28002   {
28003     try {
28004       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
28005     } catch (std::out_of_range& e) {
28006       {
28007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28008       };
28009     } catch (std::exception& e) {
28010       {
28011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28012       };
28013     } catch (...) {
28014       {
28015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28016       };
28017     }
28018   }
28019   jresult = (void *)result;
28020   return jresult;
28021 }
28022
28023
28024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
28025   void * jresult ;
28026   Dali::LongPressGesture *arg1 = 0 ;
28027   Dali::LongPressGesture *result = 0 ;
28028
28029   arg1 = (Dali::LongPressGesture *)jarg1;
28030   if (!arg1) {
28031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
28032     return 0;
28033   }
28034   {
28035     try {
28036       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
28037     } catch (std::out_of_range& e) {
28038       {
28039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28040       };
28041     } catch (std::exception& e) {
28042       {
28043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28044       };
28045     } catch (...) {
28046       {
28047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28048       };
28049     }
28050   }
28051   jresult = (void *)result;
28052   return jresult;
28053 }
28054
28055
28056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
28057   void * jresult ;
28058   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28059   Dali::LongPressGesture *arg2 = 0 ;
28060   Dali::LongPressGesture *result = 0 ;
28061
28062   arg1 = (Dali::LongPressGesture *)jarg1;
28063   arg2 = (Dali::LongPressGesture *)jarg2;
28064   if (!arg2) {
28065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
28066     return 0;
28067   }
28068   {
28069     try {
28070       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
28071     } catch (std::out_of_range& e) {
28072       {
28073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28074       };
28075     } catch (std::exception& e) {
28076       {
28077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28078       };
28079     } catch (...) {
28080       {
28081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28082       };
28083     }
28084   }
28085   jresult = (void *)result;
28086   return jresult;
28087 }
28088
28089
28090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
28091   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28092
28093   arg1 = (Dali::LongPressGesture *)jarg1;
28094   {
28095     try {
28096       delete arg1;
28097     } catch (std::out_of_range& e) {
28098       {
28099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28100       };
28101     } catch (std::exception& e) {
28102       {
28103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28104       };
28105     } catch (...) {
28106       {
28107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28108       };
28109     }
28110   }
28111 }
28112
28113
28114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
28115   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28116   unsigned int arg2 ;
28117
28118   arg1 = (Dali::LongPressGesture *)jarg1;
28119   arg2 = (unsigned int)jarg2;
28120   if (arg1) (arg1)->numberOfTouches = arg2;
28121 }
28122
28123
28124 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
28125   unsigned int jresult ;
28126   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28127   unsigned int result;
28128
28129   arg1 = (Dali::LongPressGesture *)jarg1;
28130   result = (unsigned int) ((arg1)->numberOfTouches);
28131   jresult = result;
28132   return jresult;
28133 }
28134
28135
28136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
28137   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28138   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28139
28140   arg1 = (Dali::LongPressGesture *)jarg1;
28141   arg2 = (Dali::Vector2 *)jarg2;
28142   if (arg1) (arg1)->screenPoint = *arg2;
28143 }
28144
28145
28146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
28147   void * jresult ;
28148   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28149   Dali::Vector2 *result = 0 ;
28150
28151   arg1 = (Dali::LongPressGesture *)jarg1;
28152   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
28153   jresult = (void *)result;
28154   return jresult;
28155 }
28156
28157
28158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
28159   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28160   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28161
28162   arg1 = (Dali::LongPressGesture *)jarg1;
28163   arg2 = (Dali::Vector2 *)jarg2;
28164   if (arg1) (arg1)->localPoint = *arg2;
28165 }
28166
28167
28168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
28169   void * jresult ;
28170   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28171   Dali::Vector2 *result = 0 ;
28172
28173   arg1 = (Dali::LongPressGesture *)jarg1;
28174   result = (Dali::Vector2 *)& ((arg1)->localPoint);
28175   jresult = (void *)result;
28176   return jresult;
28177 }
28178
28179
28180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
28181   void * jresult ;
28182   Dali::WheelEvent *result = 0 ;
28183
28184   {
28185     try {
28186       result = (Dali::WheelEvent *)new Dali::WheelEvent();
28187     } catch (std::out_of_range& e) {
28188       {
28189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28190       };
28191     } catch (std::exception& e) {
28192       {
28193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28194       };
28195     } catch (...) {
28196       {
28197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28198       };
28199     }
28200   }
28201   jresult = (void *)result;
28202   return jresult;
28203 }
28204
28205
28206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
28207   void * jresult ;
28208   Dali::WheelEvent::Type arg1 ;
28209   int arg2 ;
28210   unsigned int arg3 ;
28211   Dali::Vector2 arg4 ;
28212   int arg5 ;
28213   unsigned int arg6 ;
28214   Dali::Vector2 *argp4 ;
28215   Dali::WheelEvent *result = 0 ;
28216
28217   arg1 = (Dali::WheelEvent::Type)jarg1;
28218   arg2 = (int)jarg2;
28219   arg3 = (unsigned int)jarg3;
28220   argp4 = (Dali::Vector2 *)jarg4;
28221   if (!argp4) {
28222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28223     return 0;
28224   }
28225   arg4 = *argp4;
28226   arg5 = (int)jarg5;
28227   arg6 = (unsigned int)jarg6;
28228   {
28229     try {
28230       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
28231     } catch (std::out_of_range& e) {
28232       {
28233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28234       };
28235     } catch (std::exception& e) {
28236       {
28237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28238       };
28239     } catch (...) {
28240       {
28241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28242       };
28243     }
28244   }
28245   jresult = (void *)result;
28246   return jresult;
28247 }
28248
28249
28250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
28251   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28252
28253   arg1 = (Dali::WheelEvent *)jarg1;
28254   {
28255     try {
28256       delete arg1;
28257     } catch (std::out_of_range& e) {
28258       {
28259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28260       };
28261     } catch (std::exception& e) {
28262       {
28263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28264       };
28265     } catch (...) {
28266       {
28267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28268       };
28269     }
28270   }
28271 }
28272
28273
28274 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
28275   unsigned int jresult ;
28276   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28277   bool result;
28278
28279   arg1 = (Dali::WheelEvent *)jarg1;
28280   {
28281     try {
28282       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
28283     } catch (std::out_of_range& e) {
28284       {
28285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28286       };
28287     } catch (std::exception& e) {
28288       {
28289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28290       };
28291     } catch (...) {
28292       {
28293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28294       };
28295     }
28296   }
28297   jresult = result;
28298   return jresult;
28299 }
28300
28301
28302 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
28303   unsigned int jresult ;
28304   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28305   bool result;
28306
28307   arg1 = (Dali::WheelEvent *)jarg1;
28308   {
28309     try {
28310       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
28311     } catch (std::out_of_range& e) {
28312       {
28313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28314       };
28315     } catch (std::exception& e) {
28316       {
28317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28318       };
28319     } catch (...) {
28320       {
28321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28322       };
28323     }
28324   }
28325   jresult = result;
28326   return jresult;
28327 }
28328
28329
28330 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
28331   unsigned int jresult ;
28332   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28333   bool result;
28334
28335   arg1 = (Dali::WheelEvent *)jarg1;
28336   {
28337     try {
28338       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
28339     } catch (std::out_of_range& e) {
28340       {
28341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28342       };
28343     } catch (std::exception& e) {
28344       {
28345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28346       };
28347     } catch (...) {
28348       {
28349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28350       };
28351     }
28352   }
28353   jresult = result;
28354   return jresult;
28355 }
28356
28357
28358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
28359   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28360   Dali::WheelEvent::Type arg2 ;
28361
28362   arg1 = (Dali::WheelEvent *)jarg1;
28363   arg2 = (Dali::WheelEvent::Type)jarg2;
28364   if (arg1) (arg1)->type = arg2;
28365 }
28366
28367
28368 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
28369   int jresult ;
28370   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28371   Dali::WheelEvent::Type result;
28372
28373   arg1 = (Dali::WheelEvent *)jarg1;
28374   result = (Dali::WheelEvent::Type) ((arg1)->type);
28375   jresult = (int)result;
28376   return jresult;
28377 }
28378
28379
28380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
28381   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28382   int arg2 ;
28383
28384   arg1 = (Dali::WheelEvent *)jarg1;
28385   arg2 = (int)jarg2;
28386   if (arg1) (arg1)->direction = arg2;
28387 }
28388
28389
28390 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
28391   int jresult ;
28392   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28393   int result;
28394
28395   arg1 = (Dali::WheelEvent *)jarg1;
28396   result = (int) ((arg1)->direction);
28397   jresult = result;
28398   return jresult;
28399 }
28400
28401
28402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
28403   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28404   unsigned int arg2 ;
28405
28406   arg1 = (Dali::WheelEvent *)jarg1;
28407   arg2 = (unsigned int)jarg2;
28408   if (arg1) (arg1)->modifiers = arg2;
28409 }
28410
28411
28412 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
28413   unsigned int jresult ;
28414   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28415   unsigned int result;
28416
28417   arg1 = (Dali::WheelEvent *)jarg1;
28418   result = (unsigned int) ((arg1)->modifiers);
28419   jresult = result;
28420   return jresult;
28421 }
28422
28423
28424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
28425   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28426   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28427
28428   arg1 = (Dali::WheelEvent *)jarg1;
28429   arg2 = (Dali::Vector2 *)jarg2;
28430   if (arg1) (arg1)->point = *arg2;
28431 }
28432
28433
28434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
28435   void * jresult ;
28436   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28437   Dali::Vector2 *result = 0 ;
28438
28439   arg1 = (Dali::WheelEvent *)jarg1;
28440   result = (Dali::Vector2 *)& ((arg1)->point);
28441   jresult = (void *)result;
28442   return jresult;
28443 }
28444
28445
28446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
28447   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28448   int arg2 ;
28449
28450   arg1 = (Dali::WheelEvent *)jarg1;
28451   arg2 = (int)jarg2;
28452   if (arg1) (arg1)->z = arg2;
28453 }
28454
28455
28456 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
28457   int jresult ;
28458   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28459   int result;
28460
28461   arg1 = (Dali::WheelEvent *)jarg1;
28462   result = (int) ((arg1)->z);
28463   jresult = result;
28464   return jresult;
28465 }
28466
28467
28468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
28469   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28470   unsigned int arg2 ;
28471
28472   arg1 = (Dali::WheelEvent *)jarg1;
28473   arg2 = (unsigned int)jarg2;
28474   if (arg1) (arg1)->timeStamp = arg2;
28475 }
28476
28477
28478 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
28479   unsigned int jresult ;
28480   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28481   unsigned int result;
28482
28483   arg1 = (Dali::WheelEvent *)jarg1;
28484   result = (unsigned int) ((arg1)->timeStamp);
28485   jresult = result;
28486   return jresult;
28487 }
28488
28489 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
28490   char * jresult ;
28491   Dali::KeyEvent *arg1 = 0 ;
28492   std::string result;
28493
28494   arg1 = (Dali::KeyEvent *)jarg1;
28495   if (!arg1) {
28496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
28497     return 0;
28498   }
28499   {
28500     try {
28501       result = Dali::DevelKeyEvent::GetDeviceName((Dali::KeyEvent const &)*arg1);
28502     } catch (std::out_of_range& e) {
28503       {
28504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28505       };
28506     } catch (std::exception& e) {
28507       {
28508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28509       };
28510     } catch (...) {
28511       {
28512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28513       };
28514     }
28515   }
28516   jresult = SWIG_csharp_string_callback((&result)->c_str());
28517   return jresult;
28518 }
28519
28520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
28521   int jresult ;
28522   Dali::KeyEvent *arg1 = 0 ;
28523   Dali::DevelKeyEvent::DeviceClass::Type result;
28524
28525   arg1 = (Dali::KeyEvent *)jarg1;
28526   if (!arg1) {
28527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
28528     return 0;
28529   }
28530   {
28531     try {
28532       result = (Dali::DevelKeyEvent::DeviceClass::Type)Dali::DevelKeyEvent::GetDeviceClass((Dali::KeyEvent const &)*arg1);
28533     } catch (std::out_of_range& e) {
28534       {
28535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28536       };
28537     } catch (std::exception& e) {
28538       {
28539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28540       };
28541     } catch (...) {
28542       {
28543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28544       };
28545     }
28546   }
28547   jresult = (int)result;
28548   return jresult;
28549 }
28550
28551
28552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
28553   Dali::Actor arg1 ;
28554   Dali::Actor *argp1 ;
28555
28556   argp1 = (Dali::Actor *)jarg1;
28557   if (!argp1) {
28558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28559     return ;
28560   }
28561   arg1 = *argp1;
28562   {
28563     try {
28564       Dali::DevelActor::Raise(arg1);
28565     } catch (std::out_of_range& e) {
28566       {
28567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28568       };
28569     } catch (std::exception& e) {
28570       {
28571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28572       };
28573     } catch (...) {
28574       {
28575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28576       };
28577     }
28578   }
28579 }
28580
28581
28582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
28583   Dali::Actor arg1 ;
28584   Dali::Actor *argp1 ;
28585
28586   argp1 = (Dali::Actor *)jarg1;
28587   if (!argp1) {
28588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28589     return ;
28590   }
28591   arg1 = *argp1;
28592   {
28593     try {
28594       Dali::DevelActor::Lower(arg1);
28595     } catch (std::out_of_range& e) {
28596       {
28597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28598       };
28599     } catch (std::exception& e) {
28600       {
28601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28602       };
28603     } catch (...) {
28604       {
28605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28606       };
28607     }
28608   }
28609 }
28610
28611
28612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
28613   Dali::Actor arg1 ;
28614   Dali::Actor *argp1 ;
28615
28616   argp1 = (Dali::Actor *)jarg1;
28617   if (!argp1) {
28618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28619     return ;
28620   }
28621   arg1 = *argp1;
28622   {
28623     try {
28624       Dali::DevelActor::RaiseToTop(arg1);
28625     } catch (std::out_of_range& e) {
28626       {
28627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28628       };
28629     } catch (std::exception& e) {
28630       {
28631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28632       };
28633     } catch (...) {
28634       {
28635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28636       };
28637     }
28638   }
28639 }
28640
28641
28642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
28643   Dali::Actor arg1 ;
28644   Dali::Actor *argp1 ;
28645
28646   argp1 = (Dali::Actor *)jarg1;
28647   if (!argp1) {
28648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28649     return ;
28650   }
28651   arg1 = *argp1;
28652   {
28653     try {
28654       Dali::DevelActor::LowerToBottom(arg1);
28655     } catch (std::out_of_range& e) {
28656       {
28657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28658       };
28659     } catch (std::exception& e) {
28660       {
28661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28662       };
28663     } catch (...) {
28664       {
28665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28666       };
28667     }
28668   }
28669 }
28670
28671
28672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
28673   Dali::Actor arg1 ;
28674   Dali::Actor arg2 ;
28675   Dali::Actor *argp1 ;
28676   Dali::Actor *argp2 ;
28677
28678   argp1 = (Dali::Actor *)jarg1;
28679   if (!argp1) {
28680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28681     return ;
28682   }
28683   arg1 = *argp1;
28684   argp2 = (Dali::Actor *)jarg2;
28685   if (!argp2) {
28686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28687     return ;
28688   }
28689   arg2 = *argp2;
28690   {
28691     try {
28692       Dali::DevelActor::RaiseAbove(arg1,arg2);
28693     } catch (std::out_of_range& e) {
28694       {
28695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28696       };
28697     } catch (std::exception& e) {
28698       {
28699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28700       };
28701     } catch (...) {
28702       {
28703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28704       };
28705     }
28706   }
28707 }
28708
28709
28710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
28711   Dali::Actor arg1 ;
28712   Dali::Actor arg2 ;
28713   Dali::Actor *argp1 ;
28714   Dali::Actor *argp2 ;
28715
28716   argp1 = (Dali::Actor *)jarg1;
28717   if (!argp1) {
28718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28719     return ;
28720   }
28721   arg1 = *argp1;
28722   argp2 = (Dali::Actor *)jarg2;
28723   if (!argp2) {
28724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28725     return ;
28726   }
28727   arg2 = *argp2;
28728   {
28729     try {
28730       Dali::DevelActor::LowerBelow(arg1,arg2);
28731     } catch (std::out_of_range& e) {
28732       {
28733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28734       };
28735     } catch (std::exception& e) {
28736       {
28737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28738       };
28739     } catch (...) {
28740       {
28741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28742       };
28743     }
28744   }
28745 }
28746
28747
28748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
28749   void * jresult ;
28750   Dali::Actor arg1 ;
28751   Dali::Actor *argp1 ;
28752   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
28753
28754   argp1 = (Dali::Actor *)jarg1;
28755   if (!argp1) {
28756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28757     return 0;
28758   }
28759   arg1 = *argp1;
28760   {
28761     try {
28762       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
28763     } catch (std::out_of_range& e) {
28764       {
28765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28766       };
28767     } catch (std::exception& e) {
28768       {
28769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28770       };
28771     } catch (...) {
28772       {
28773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28774       };
28775     }
28776   }
28777   jresult = (void *)result;
28778   return jresult;
28779 }
28780
28781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
28782   int jresult ;
28783   int result;
28784
28785   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
28786   jresult = (int)result;
28787   return jresult;
28788 }
28789
28790
28791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
28792   int jresult ;
28793   int result;
28794
28795   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
28796   jresult = (int)result;
28797   return jresult;
28798 }
28799
28800
28801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
28802   int jresult ;
28803   int result;
28804
28805   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
28806   jresult = (int)result;
28807   return jresult;
28808 }
28809
28810
28811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
28812   int jresult ;
28813   int result;
28814
28815   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
28816   jresult = (int)result;
28817   return jresult;
28818 }
28819
28820
28821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
28822   int jresult ;
28823   int result;
28824
28825   result = (int)Dali::Actor::Property::ANCHOR_POINT;
28826   jresult = (int)result;
28827   return jresult;
28828 }
28829
28830
28831 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
28832   int jresult ;
28833   int result;
28834
28835   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
28836   jresult = (int)result;
28837   return jresult;
28838 }
28839
28840
28841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
28842   int jresult ;
28843   int result;
28844
28845   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
28846   jresult = (int)result;
28847   return jresult;
28848 }
28849
28850
28851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
28852   int jresult ;
28853   int result;
28854
28855   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
28856   jresult = (int)result;
28857   return jresult;
28858 }
28859
28860
28861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
28862   int jresult ;
28863   int result;
28864
28865   result = (int)Dali::Actor::Property::SIZE;
28866   jresult = (int)result;
28867   return jresult;
28868 }
28869
28870
28871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
28872   int jresult ;
28873   int result;
28874
28875   result = (int)Dali::Actor::Property::SIZE_WIDTH;
28876   jresult = (int)result;
28877   return jresult;
28878 }
28879
28880
28881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
28882   int jresult ;
28883   int result;
28884
28885   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
28886   jresult = (int)result;
28887   return jresult;
28888 }
28889
28890
28891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
28892   int jresult ;
28893   int result;
28894
28895   result = (int)Dali::Actor::Property::SIZE_DEPTH;
28896   jresult = (int)result;
28897   return jresult;
28898 }
28899
28900
28901 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
28902   int jresult ;
28903   int result;
28904
28905   result = (int)Dali::Actor::Property::POSITION;
28906   jresult = (int)result;
28907   return jresult;
28908 }
28909
28910
28911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
28912   int jresult ;
28913   int result;
28914
28915   result = (int)Dali::Actor::Property::POSITION_X;
28916   jresult = (int)result;
28917   return jresult;
28918 }
28919
28920
28921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
28922   int jresult ;
28923   int result;
28924
28925   result = (int)Dali::Actor::Property::POSITION_Y;
28926   jresult = (int)result;
28927   return jresult;
28928 }
28929
28930
28931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
28932   int jresult ;
28933   int result;
28934
28935   result = (int)Dali::Actor::Property::POSITION_Z;
28936   jresult = (int)result;
28937   return jresult;
28938 }
28939
28940
28941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
28942   int jresult ;
28943   int result;
28944
28945   result = (int)Dali::Actor::Property::WORLD_POSITION;
28946   jresult = (int)result;
28947   return jresult;
28948 }
28949
28950
28951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
28952   int jresult ;
28953   int result;
28954
28955   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
28956   jresult = (int)result;
28957   return jresult;
28958 }
28959
28960
28961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
28962   int jresult ;
28963   int result;
28964
28965   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
28966   jresult = (int)result;
28967   return jresult;
28968 }
28969
28970
28971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
28972   int jresult ;
28973   int result;
28974
28975   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
28976   jresult = (int)result;
28977   return jresult;
28978 }
28979
28980
28981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
28982   int jresult ;
28983   int result;
28984
28985   result = (int)Dali::Actor::Property::ORIENTATION;
28986   jresult = (int)result;
28987   return jresult;
28988 }
28989
28990
28991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
28992   int jresult ;
28993   int result;
28994
28995   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
28996   jresult = (int)result;
28997   return jresult;
28998 }
28999
29000
29001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
29002   int jresult ;
29003   int result;
29004
29005   result = (int)Dali::Actor::Property::SCALE;
29006   jresult = (int)result;
29007   return jresult;
29008 }
29009
29010
29011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
29012   int jresult ;
29013   int result;
29014
29015   result = (int)Dali::Actor::Property::SCALE_X;
29016   jresult = (int)result;
29017   return jresult;
29018 }
29019
29020
29021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
29022   int jresult ;
29023   int result;
29024
29025   result = (int)Dali::Actor::Property::SCALE_Y;
29026   jresult = (int)result;
29027   return jresult;
29028 }
29029
29030
29031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
29032   int jresult ;
29033   int result;
29034
29035   result = (int)Dali::Actor::Property::SCALE_Z;
29036   jresult = (int)result;
29037   return jresult;
29038 }
29039
29040
29041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
29042   int jresult ;
29043   int result;
29044
29045   result = (int)Dali::Actor::Property::WORLD_SCALE;
29046   jresult = (int)result;
29047   return jresult;
29048 }
29049
29050
29051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
29052   int jresult ;
29053   int result;
29054
29055   result = (int)Dali::Actor::Property::VISIBLE;
29056   jresult = (int)result;
29057   return jresult;
29058 }
29059
29060
29061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
29062   int jresult ;
29063   int result;
29064
29065   result = (int)Dali::Actor::Property::COLOR;
29066   jresult = (int)result;
29067   return jresult;
29068 }
29069
29070
29071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
29072   int jresult ;
29073   int result;
29074
29075   result = (int)Dali::Actor::Property::COLOR_RED;
29076   jresult = (int)result;
29077   return jresult;
29078 }
29079
29080
29081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
29082   int jresult ;
29083   int result;
29084
29085   result = (int)Dali::Actor::Property::COLOR_GREEN;
29086   jresult = (int)result;
29087   return jresult;
29088 }
29089
29090
29091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
29092   int jresult ;
29093   int result;
29094
29095   result = (int)Dali::Actor::Property::COLOR_BLUE;
29096   jresult = (int)result;
29097   return jresult;
29098 }
29099
29100
29101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
29102   int jresult ;
29103   int result;
29104
29105   result = (int)Dali::Actor::Property::COLOR_ALPHA;
29106   jresult = (int)result;
29107   return jresult;
29108 }
29109
29110
29111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
29112   int jresult ;
29113   int result;
29114
29115   result = (int)Dali::Actor::Property::WORLD_COLOR;
29116   jresult = (int)result;
29117   return jresult;
29118 }
29119
29120
29121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
29122   int jresult ;
29123   int result;
29124
29125   result = (int)Dali::Actor::Property::WORLD_MATRIX;
29126   jresult = (int)result;
29127   return jresult;
29128 }
29129
29130
29131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
29132   int jresult ;
29133   int result;
29134
29135   result = (int)Dali::Actor::Property::NAME;
29136   jresult = (int)result;
29137   return jresult;
29138 }
29139
29140
29141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
29142   int jresult ;
29143   int result;
29144
29145   result = (int)Dali::Actor::Property::SENSITIVE;
29146   jresult = (int)result;
29147   return jresult;
29148 }
29149
29150
29151 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
29152   int jresult ;
29153   int result;
29154
29155   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
29156   jresult = (int)result;
29157   return jresult;
29158 }
29159
29160
29161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
29162   int jresult ;
29163   int result;
29164
29165   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
29166   jresult = (int)result;
29167   return jresult;
29168 }
29169
29170
29171 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
29172   int jresult ;
29173   int result;
29174
29175   result = (int)Dali::Actor::Property::INHERIT_SCALE;
29176   jresult = (int)result;
29177   return jresult;
29178 }
29179
29180
29181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
29182   int jresult ;
29183   int result;
29184
29185   result = (int)Dali::Actor::Property::COLOR_MODE;
29186   jresult = (int)result;
29187   return jresult;
29188 }
29189
29190
29191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_INHERITANCE_get() {
29192   int jresult ;
29193   int result;
29194
29195   result = (int)Dali::Actor::Property::POSITION_INHERITANCE;
29196   jresult = (int)result;
29197   return jresult;
29198 }
29199
29200
29201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
29202   int jresult ;
29203   int result;
29204
29205   result = (int)Dali::Actor::Property::DRAW_MODE;
29206   jresult = (int)result;
29207   return jresult;
29208 }
29209
29210
29211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
29212   int jresult ;
29213   int result;
29214
29215   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
29216   jresult = (int)result;
29217   return jresult;
29218 }
29219
29220
29221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
29222   int jresult ;
29223   int result;
29224
29225   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
29226   jresult = (int)result;
29227   return jresult;
29228 }
29229
29230
29231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
29232   int jresult ;
29233   int result;
29234
29235   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
29236   jresult = (int)result;
29237   return jresult;
29238 }
29239
29240
29241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
29242   int jresult ;
29243   int result;
29244
29245   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
29246   jresult = (int)result;
29247   return jresult;
29248 }
29249
29250
29251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
29252   int jresult ;
29253   int result;
29254
29255   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
29256   jresult = (int)result;
29257   return jresult;
29258 }
29259
29260
29261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
29262   int jresult ;
29263   int result;
29264
29265   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
29266   jresult = (int)result;
29267   return jresult;
29268 }
29269
29270
29271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
29272   int jresult ;
29273   int result;
29274
29275   result = (int)Dali::Actor::Property::PADDING;
29276   jresult = (int)result;
29277   return jresult;
29278 }
29279
29280
29281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
29282   int jresult ;
29283   int result;
29284
29285   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
29286   jresult = (int)result;
29287   return jresult;
29288 }
29289
29290
29291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
29292   int jresult ;
29293   int result;
29294
29295   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
29296   jresult = (int)result;
29297   return jresult;
29298 }
29299
29300
29301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
29302   int jresult ;
29303   int result;
29304
29305   result = (int)Dali::Actor::Property::INHERIT_POSITION;
29306   jresult = (int)result;
29307   return jresult;
29308 }
29309
29310
29311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
29312   int jresult ;
29313   int result;
29314
29315   result = (int)Dali::Actor::Property::CLIPPING_MODE;
29316   jresult = (int)result;
29317   return jresult;
29318 }
29319
29320
29321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
29322   void * jresult ;
29323   Dali::Actor::Property *result = 0 ;
29324
29325   {
29326     try {
29327       result = (Dali::Actor::Property *)new Dali::Actor::Property();
29328     } catch (std::out_of_range& e) {
29329       {
29330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29331       };
29332     } catch (std::exception& e) {
29333       {
29334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29335       };
29336     } catch (...) {
29337       {
29338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29339       };
29340     }
29341   }
29342   jresult = (void *)result;
29343   return jresult;
29344 }
29345
29346
29347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
29348   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
29349
29350   arg1 = (Dali::Actor::Property *)jarg1;
29351   {
29352     try {
29353       delete arg1;
29354     } catch (std::out_of_range& e) {
29355       {
29356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29357       };
29358     } catch (std::exception& e) {
29359       {
29360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29361       };
29362     } catch (...) {
29363       {
29364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29365       };
29366     }
29367   }
29368 }
29369
29370
29371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
29372   void * jresult ;
29373   Dali::Actor *result = 0 ;
29374
29375   {
29376     try {
29377       result = (Dali::Actor *)new Dali::Actor();
29378     } catch (std::out_of_range& e) {
29379       {
29380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29381       };
29382     } catch (std::exception& e) {
29383       {
29384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29385       };
29386     } catch (...) {
29387       {
29388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29389       };
29390     }
29391   }
29392   jresult = (void *)result;
29393   return jresult;
29394 }
29395
29396
29397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
29398   void * jresult ;
29399   Dali::Actor result;
29400
29401   {
29402     try {
29403       result = Dali::Actor::New();
29404     } catch (std::out_of_range& e) {
29405       {
29406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29407       };
29408     } catch (std::exception& e) {
29409       {
29410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29411       };
29412     } catch (...) {
29413       {
29414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29415       };
29416     }
29417   }
29418   jresult = new Dali::Actor((const Dali::Actor &)result);
29419   return jresult;
29420 }
29421
29422
29423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
29424   void * jresult ;
29425   Dali::BaseHandle arg1 ;
29426   Dali::BaseHandle *argp1 ;
29427   Dali::Actor result;
29428
29429   argp1 = (Dali::BaseHandle *)jarg1;
29430   if (!argp1) {
29431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
29432     return 0;
29433   }
29434   arg1 = *argp1;
29435   {
29436     try {
29437       result = Dali::Actor::DownCast(arg1);
29438     } catch (std::out_of_range& e) {
29439       {
29440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29441       };
29442     } catch (std::exception& e) {
29443       {
29444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29445       };
29446     } catch (...) {
29447       {
29448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29449       };
29450     }
29451   }
29452   jresult = new Dali::Actor((const Dali::Actor &)result);
29453   return jresult;
29454 }
29455
29456
29457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
29458   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29459
29460   arg1 = (Dali::Actor *)jarg1;
29461   {
29462     try {
29463       delete arg1;
29464     } catch (std::out_of_range& e) {
29465       {
29466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29467       };
29468     } catch (std::exception& e) {
29469       {
29470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29471       };
29472     } catch (...) {
29473       {
29474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29475       };
29476     }
29477   }
29478 }
29479
29480
29481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
29482   void * jresult ;
29483   Dali::Actor *arg1 = 0 ;
29484   Dali::Actor *result = 0 ;
29485
29486   arg1 = (Dali::Actor *)jarg1;
29487   if (!arg1) {
29488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29489     return 0;
29490   }
29491   {
29492     try {
29493       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
29494     } catch (std::out_of_range& e) {
29495       {
29496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29497       };
29498     } catch (std::exception& e) {
29499       {
29500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29501       };
29502     } catch (...) {
29503       {
29504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29505       };
29506     }
29507   }
29508   jresult = (void *)result;
29509   return jresult;
29510 }
29511
29512
29513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
29514   void * jresult ;
29515   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29516   Dali::Actor *arg2 = 0 ;
29517   Dali::Actor *result = 0 ;
29518
29519   arg1 = (Dali::Actor *)jarg1;
29520   arg2 = (Dali::Actor *)jarg2;
29521   if (!arg2) {
29522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29523     return 0;
29524   }
29525   {
29526     try {
29527       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
29528     } catch (std::out_of_range& e) {
29529       {
29530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29531       };
29532     } catch (std::exception& e) {
29533       {
29534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29535       };
29536     } catch (...) {
29537       {
29538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29539       };
29540     }
29541   }
29542   jresult = (void *)result;
29543   return jresult;
29544 }
29545
29546
29547 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
29548   char * jresult ;
29549   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29550   std::string *result = 0 ;
29551
29552   arg1 = (Dali::Actor *)jarg1;
29553   {
29554     try {
29555       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
29556     } catch (std::out_of_range& e) {
29557       {
29558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29559       };
29560     } catch (std::exception& e) {
29561       {
29562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29563       };
29564     } catch (...) {
29565       {
29566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29567       };
29568     }
29569   }
29570   jresult = SWIG_csharp_string_callback(result->c_str());
29571   return jresult;
29572 }
29573
29574
29575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
29576   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29577   std::string *arg2 = 0 ;
29578
29579   arg1 = (Dali::Actor *)jarg1;
29580   if (!jarg2) {
29581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29582     return ;
29583   }
29584   std::string arg2_str(jarg2);
29585   arg2 = &arg2_str;
29586   {
29587     try {
29588       (arg1)->SetName((std::string const &)*arg2);
29589     } catch (std::out_of_range& e) {
29590       {
29591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29592       };
29593     } catch (std::exception& e) {
29594       {
29595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29596       };
29597     } catch (...) {
29598       {
29599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29600       };
29601     }
29602   }
29603
29604   //argout typemap for const std::string&
29605
29606 }
29607
29608
29609 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
29610   unsigned int jresult ;
29611   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29612   unsigned int result;
29613
29614   arg1 = (Dali::Actor *)jarg1;
29615   {
29616     try {
29617       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
29618     } catch (std::out_of_range& e) {
29619       {
29620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29621       };
29622     } catch (std::exception& e) {
29623       {
29624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29625       };
29626     } catch (...) {
29627       {
29628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29629       };
29630     }
29631   }
29632   jresult = result;
29633   return jresult;
29634 }
29635
29636
29637 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
29638   unsigned int jresult ;
29639   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29640   bool result;
29641
29642   arg1 = (Dali::Actor *)jarg1;
29643   {
29644     try {
29645       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
29646     } catch (std::out_of_range& e) {
29647       {
29648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29649       };
29650     } catch (std::exception& e) {
29651       {
29652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29653       };
29654     } catch (...) {
29655       {
29656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29657       };
29658     }
29659   }
29660   jresult = result;
29661   return jresult;
29662 }
29663
29664
29665 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
29666   unsigned int jresult ;
29667   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29668   bool result;
29669
29670   arg1 = (Dali::Actor *)jarg1;
29671   {
29672     try {
29673       result = (bool)((Dali::Actor const *)arg1)->OnStage();
29674     } catch (std::out_of_range& e) {
29675       {
29676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29677       };
29678     } catch (std::exception& e) {
29679       {
29680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29681       };
29682     } catch (...) {
29683       {
29684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29685       };
29686     }
29687   }
29688   jresult = result;
29689   return jresult;
29690 }
29691
29692
29693 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
29694   unsigned int jresult ;
29695   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29696   bool result;
29697
29698   arg1 = (Dali::Actor *)jarg1;
29699   {
29700     try {
29701       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
29702     } catch (std::out_of_range& e) {
29703       {
29704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29705       };
29706     } catch (std::exception& e) {
29707       {
29708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29709       };
29710     } catch (...) {
29711       {
29712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29713       };
29714     }
29715   }
29716   jresult = result;
29717   return jresult;
29718 }
29719
29720
29721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
29722   void * jresult ;
29723   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29724   Dali::Layer result;
29725
29726   arg1 = (Dali::Actor *)jarg1;
29727   {
29728     try {
29729       result = (arg1)->GetLayer();
29730     } catch (std::out_of_range& e) {
29731       {
29732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29733       };
29734     } catch (std::exception& e) {
29735       {
29736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29737       };
29738     } catch (...) {
29739       {
29740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29741       };
29742     }
29743   }
29744   jresult = new Dali::Layer((const Dali::Layer &)result);
29745   return jresult;
29746 }
29747
29748
29749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
29750   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29751   Dali::Actor arg2 ;
29752   Dali::Actor *argp2 ;
29753
29754   arg1 = (Dali::Actor *)jarg1;
29755   argp2 = (Dali::Actor *)jarg2;
29756   if (!argp2) {
29757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29758     return ;
29759   }
29760   arg2 = *argp2;
29761   {
29762     try {
29763       (arg1)->Add(arg2);
29764     } catch (std::out_of_range& e) {
29765       {
29766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29767       };
29768     } catch (std::exception& e) {
29769       {
29770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29771       };
29772     } catch (...) {
29773       {
29774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29775       };
29776     }
29777   }
29778 }
29779
29780
29781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
29782   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29783   Dali::Actor arg2 ;
29784   Dali::Actor *argp2 ;
29785
29786   arg1 = (Dali::Actor *)jarg1;
29787   argp2 = (Dali::Actor *)jarg2;
29788   if (!argp2) {
29789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29790     return ;
29791   }
29792   arg2 = *argp2;
29793   {
29794     try {
29795       (arg1)->Remove(arg2);
29796     } catch (std::out_of_range& e) {
29797       {
29798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29799       };
29800     } catch (std::exception& e) {
29801       {
29802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29803       };
29804     } catch (...) {
29805       {
29806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29807       };
29808     }
29809   }
29810 }
29811
29812
29813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
29814   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29815
29816   arg1 = (Dali::Actor *)jarg1;
29817   {
29818     try {
29819       (arg1)->Unparent();
29820     } catch (std::out_of_range& e) {
29821       {
29822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29823       };
29824     } catch (std::exception& e) {
29825       {
29826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29827       };
29828     } catch (...) {
29829       {
29830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29831       };
29832     }
29833   }
29834 }
29835
29836
29837 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
29838   unsigned int jresult ;
29839   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29840   unsigned int result;
29841
29842   arg1 = (Dali::Actor *)jarg1;
29843   {
29844     try {
29845       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
29846     } catch (std::out_of_range& e) {
29847       {
29848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29849       };
29850     } catch (std::exception& e) {
29851       {
29852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29853       };
29854     } catch (...) {
29855       {
29856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29857       };
29858     }
29859   }
29860   jresult = result;
29861   return jresult;
29862 }
29863
29864
29865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
29866   void * jresult ;
29867   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29868   unsigned int arg2 ;
29869   Dali::Actor result;
29870
29871   arg1 = (Dali::Actor *)jarg1;
29872   arg2 = (unsigned int)jarg2;
29873   {
29874     try {
29875       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
29876     } catch (std::out_of_range& e) {
29877       {
29878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29879       };
29880     } catch (std::exception& e) {
29881       {
29882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29883       };
29884     } catch (...) {
29885       {
29886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29887       };
29888     }
29889   }
29890   jresult = new Dali::Actor((const Dali::Actor &)result);
29891   return jresult;
29892 }
29893
29894
29895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
29896   void * jresult ;
29897   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29898   std::string *arg2 = 0 ;
29899   Dali::Actor result;
29900
29901   arg1 = (Dali::Actor *)jarg1;
29902   if (!jarg2) {
29903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29904     return 0;
29905   }
29906   std::string arg2_str(jarg2);
29907   arg2 = &arg2_str;
29908   {
29909     try {
29910       result = (arg1)->FindChildByName((std::string const &)*arg2);
29911     } catch (std::out_of_range& e) {
29912       {
29913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29914       };
29915     } catch (std::exception& e) {
29916       {
29917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29918       };
29919     } catch (...) {
29920       {
29921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29922       };
29923     }
29924   }
29925   jresult = new Dali::Actor((const Dali::Actor &)result);
29926
29927   //argout typemap for const std::string&
29928
29929   return jresult;
29930 }
29931
29932
29933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
29934   void * jresult ;
29935   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29936   unsigned int arg2 ;
29937   Dali::Actor result;
29938
29939   arg1 = (Dali::Actor *)jarg1;
29940   arg2 = (unsigned int)jarg2;
29941   {
29942     try {
29943       result = (arg1)->FindChildById(arg2);
29944     } catch (std::out_of_range& e) {
29945       {
29946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29947       };
29948     } catch (std::exception& e) {
29949       {
29950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29951       };
29952     } catch (...) {
29953       {
29954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29955       };
29956     }
29957   }
29958   jresult = new Dali::Actor((const Dali::Actor &)result);
29959   return jresult;
29960 }
29961
29962
29963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
29964   void * jresult ;
29965   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29966   Dali::Actor result;
29967
29968   arg1 = (Dali::Actor *)jarg1;
29969   {
29970     try {
29971       result = ((Dali::Actor const *)arg1)->GetParent();
29972     } catch (std::out_of_range& e) {
29973       {
29974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29975       };
29976     } catch (std::exception& e) {
29977       {
29978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29979       };
29980     } catch (...) {
29981       {
29982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29983       };
29984     }
29985   }
29986   jresult = new Dali::Actor((const Dali::Actor &)result);
29987   return jresult;
29988 }
29989
29990
29991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
29992   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29993   Dali::Vector3 *arg2 = 0 ;
29994
29995   arg1 = (Dali::Actor *)jarg1;
29996   arg2 = (Dali::Vector3 *)jarg2;
29997   if (!arg2) {
29998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29999     return ;
30000   }
30001   {
30002     try {
30003       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
30004     } catch (std::out_of_range& e) {
30005       {
30006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30007       };
30008     } catch (std::exception& e) {
30009       {
30010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30011       };
30012     } catch (...) {
30013       {
30014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30015       };
30016     }
30017   }
30018 }
30019
30020
30021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
30022   void * jresult ;
30023   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30024   Dali::Vector3 result;
30025
30026   arg1 = (Dali::Actor *)jarg1;
30027   {
30028     try {
30029       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
30030     } catch (std::out_of_range& e) {
30031       {
30032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30033       };
30034     } catch (std::exception& e) {
30035       {
30036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30037       };
30038     } catch (...) {
30039       {
30040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30041       };
30042     }
30043   }
30044   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30045   return jresult;
30046 }
30047
30048
30049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
30050   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30051   Dali::Vector3 *arg2 = 0 ;
30052
30053   arg1 = (Dali::Actor *)jarg1;
30054   arg2 = (Dali::Vector3 *)jarg2;
30055   if (!arg2) {
30056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30057     return ;
30058   }
30059   {
30060     try {
30061       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
30062     } catch (std::out_of_range& e) {
30063       {
30064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30065       };
30066     } catch (std::exception& e) {
30067       {
30068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30069       };
30070     } catch (...) {
30071       {
30072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30073       };
30074     }
30075   }
30076 }
30077
30078
30079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
30080   void * jresult ;
30081   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30082   Dali::Vector3 result;
30083
30084   arg1 = (Dali::Actor *)jarg1;
30085   {
30086     try {
30087       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
30088     } catch (std::out_of_range& e) {
30089       {
30090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30091       };
30092     } catch (std::exception& e) {
30093       {
30094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30095       };
30096     } catch (...) {
30097       {
30098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30099       };
30100     }
30101   }
30102   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30103   return jresult;
30104 }
30105
30106
30107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
30108   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30109   float arg2 ;
30110   float arg3 ;
30111
30112   arg1 = (Dali::Actor *)jarg1;
30113   arg2 = (float)jarg2;
30114   arg3 = (float)jarg3;
30115   {
30116     try {
30117       (arg1)->SetSize(arg2,arg3);
30118     } catch (std::out_of_range& e) {
30119       {
30120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30121       };
30122     } catch (std::exception& e) {
30123       {
30124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30125       };
30126     } catch (...) {
30127       {
30128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30129       };
30130     }
30131   }
30132 }
30133
30134
30135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30136   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30137   float arg2 ;
30138   float arg3 ;
30139   float arg4 ;
30140
30141   arg1 = (Dali::Actor *)jarg1;
30142   arg2 = (float)jarg2;
30143   arg3 = (float)jarg3;
30144   arg4 = (float)jarg4;
30145   {
30146     try {
30147       (arg1)->SetSize(arg2,arg3,arg4);
30148     } catch (std::out_of_range& e) {
30149       {
30150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30151       };
30152     } catch (std::exception& e) {
30153       {
30154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30155       };
30156     } catch (...) {
30157       {
30158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30159       };
30160     }
30161   }
30162 }
30163
30164
30165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
30166   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30167   Dali::Vector2 *arg2 = 0 ;
30168
30169   arg1 = (Dali::Actor *)jarg1;
30170   arg2 = (Dali::Vector2 *)jarg2;
30171   if (!arg2) {
30172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
30173     return ;
30174   }
30175   {
30176     try {
30177       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
30178     } catch (std::out_of_range& e) {
30179       {
30180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30181       };
30182     } catch (std::exception& e) {
30183       {
30184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30185       };
30186     } catch (...) {
30187       {
30188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30189       };
30190     }
30191   }
30192 }
30193
30194
30195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
30196   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30197   Dali::Vector3 *arg2 = 0 ;
30198
30199   arg1 = (Dali::Actor *)jarg1;
30200   arg2 = (Dali::Vector3 *)jarg2;
30201   if (!arg2) {
30202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30203     return ;
30204   }
30205   {
30206     try {
30207       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
30208     } catch (std::out_of_range& e) {
30209       {
30210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30211       };
30212     } catch (std::exception& e) {
30213       {
30214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30215       };
30216     } catch (...) {
30217       {
30218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30219       };
30220     }
30221   }
30222 }
30223
30224
30225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
30226   void * jresult ;
30227   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30228   Dali::Vector3 result;
30229
30230   arg1 = (Dali::Actor *)jarg1;
30231   {
30232     try {
30233       result = ((Dali::Actor const *)arg1)->GetTargetSize();
30234     } catch (std::out_of_range& e) {
30235       {
30236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30237       };
30238     } catch (std::exception& e) {
30239       {
30240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30241       };
30242     } catch (...) {
30243       {
30244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30245       };
30246     }
30247   }
30248   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30249   return jresult;
30250 }
30251
30252
30253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
30254   void * jresult ;
30255   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30256   Dali::Vector3 result;
30257
30258   arg1 = (Dali::Actor *)jarg1;
30259   {
30260     try {
30261       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
30262     } catch (std::out_of_range& e) {
30263       {
30264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30265       };
30266     } catch (std::exception& e) {
30267       {
30268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30269       };
30270     } catch (...) {
30271       {
30272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30273       };
30274     }
30275   }
30276   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30277   return jresult;
30278 }
30279
30280
30281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
30282   void * jresult ;
30283   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30284   Dali::Vector3 result;
30285
30286   arg1 = (Dali::Actor *)jarg1;
30287   {
30288     try {
30289       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
30290     } catch (std::out_of_range& e) {
30291       {
30292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30293       };
30294     } catch (std::exception& e) {
30295       {
30296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30297       };
30298     } catch (...) {
30299       {
30300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30301       };
30302     }
30303   }
30304   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30305   return jresult;
30306 }
30307
30308
30309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
30310   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30311   float arg2 ;
30312   float arg3 ;
30313
30314   arg1 = (Dali::Actor *)jarg1;
30315   arg2 = (float)jarg2;
30316   arg3 = (float)jarg3;
30317   {
30318     try {
30319       (arg1)->SetPosition(arg2,arg3);
30320     } catch (std::out_of_range& e) {
30321       {
30322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30323       };
30324     } catch (std::exception& e) {
30325       {
30326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30327       };
30328     } catch (...) {
30329       {
30330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30331       };
30332     }
30333   }
30334 }
30335
30336
30337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30338   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30339   float arg2 ;
30340   float arg3 ;
30341   float arg4 ;
30342
30343   arg1 = (Dali::Actor *)jarg1;
30344   arg2 = (float)jarg2;
30345   arg3 = (float)jarg3;
30346   arg4 = (float)jarg4;
30347   {
30348     try {
30349       (arg1)->SetPosition(arg2,arg3,arg4);
30350     } catch (std::out_of_range& e) {
30351       {
30352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30353       };
30354     } catch (std::exception& e) {
30355       {
30356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30357       };
30358     } catch (...) {
30359       {
30360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30361       };
30362     }
30363   }
30364 }
30365
30366
30367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
30368   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30369   Dali::Vector3 *arg2 = 0 ;
30370
30371   arg1 = (Dali::Actor *)jarg1;
30372   arg2 = (Dali::Vector3 *)jarg2;
30373   if (!arg2) {
30374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30375     return ;
30376   }
30377   {
30378     try {
30379       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
30380     } catch (std::out_of_range& e) {
30381       {
30382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30383       };
30384     } catch (std::exception& e) {
30385       {
30386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30387       };
30388     } catch (...) {
30389       {
30390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30391       };
30392     }
30393   }
30394 }
30395
30396
30397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
30398   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30399   float arg2 ;
30400
30401   arg1 = (Dali::Actor *)jarg1;
30402   arg2 = (float)jarg2;
30403   {
30404     try {
30405       (arg1)->SetX(arg2);
30406     } catch (std::out_of_range& e) {
30407       {
30408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30409       };
30410     } catch (std::exception& e) {
30411       {
30412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30413       };
30414     } catch (...) {
30415       {
30416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30417       };
30418     }
30419   }
30420 }
30421
30422
30423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
30424   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30425   float arg2 ;
30426
30427   arg1 = (Dali::Actor *)jarg1;
30428   arg2 = (float)jarg2;
30429   {
30430     try {
30431       (arg1)->SetY(arg2);
30432     } catch (std::out_of_range& e) {
30433       {
30434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30435       };
30436     } catch (std::exception& e) {
30437       {
30438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30439       };
30440     } catch (...) {
30441       {
30442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30443       };
30444     }
30445   }
30446 }
30447
30448
30449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
30450   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30451   float arg2 ;
30452
30453   arg1 = (Dali::Actor *)jarg1;
30454   arg2 = (float)jarg2;
30455   {
30456     try {
30457       (arg1)->SetZ(arg2);
30458     } catch (std::out_of_range& e) {
30459       {
30460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30461       };
30462     } catch (std::exception& e) {
30463       {
30464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30465       };
30466     } catch (...) {
30467       {
30468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30469       };
30470     }
30471   }
30472 }
30473
30474
30475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
30476   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30477   Dali::Vector3 *arg2 = 0 ;
30478
30479   arg1 = (Dali::Actor *)jarg1;
30480   arg2 = (Dali::Vector3 *)jarg2;
30481   if (!arg2) {
30482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30483     return ;
30484   }
30485   {
30486     try {
30487       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
30488     } catch (std::out_of_range& e) {
30489       {
30490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30491       };
30492     } catch (std::exception& e) {
30493       {
30494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30495       };
30496     } catch (...) {
30497       {
30498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30499       };
30500     }
30501   }
30502 }
30503
30504
30505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
30506   void * jresult ;
30507   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30508   Dali::Vector3 result;
30509
30510   arg1 = (Dali::Actor *)jarg1;
30511   {
30512     try {
30513       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
30514     } catch (std::out_of_range& e) {
30515       {
30516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30517       };
30518     } catch (std::exception& e) {
30519       {
30520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30521       };
30522     } catch (...) {
30523       {
30524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30525       };
30526     }
30527   }
30528   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30529   return jresult;
30530 }
30531
30532
30533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
30534   void * jresult ;
30535   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30536   Dali::Vector3 result;
30537
30538   arg1 = (Dali::Actor *)jarg1;
30539   {
30540     try {
30541       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
30542     } catch (std::out_of_range& e) {
30543       {
30544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30545       };
30546     } catch (std::exception& e) {
30547       {
30548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30549       };
30550     } catch (...) {
30551       {
30552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30553       };
30554     }
30555   }
30556   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30557   return jresult;
30558 }
30559
30560
30561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
30562   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30563   bool arg2 ;
30564
30565   arg1 = (Dali::Actor *)jarg1;
30566   arg2 = jarg2 ? true : false;
30567   {
30568     try {
30569       (arg1)->SetInheritPosition(arg2);
30570     } catch (std::out_of_range& e) {
30571       {
30572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30573       };
30574     } catch (std::exception& e) {
30575       {
30576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30577       };
30578     } catch (...) {
30579       {
30580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30581       };
30582     }
30583   }
30584 }
30585
30586
30587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetPositionInheritanceMode(void * jarg1) {
30588   int jresult ;
30589   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30590   Dali::PositionInheritanceMode result;
30591
30592   arg1 = (Dali::Actor *)jarg1;
30593   {
30594     try {
30595       result = (Dali::PositionInheritanceMode)((Dali::Actor const *)arg1)->GetPositionInheritanceMode();
30596     } catch (std::out_of_range& e) {
30597       {
30598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30599       };
30600     } catch (std::exception& e) {
30601       {
30602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30603       };
30604     } catch (...) {
30605       {
30606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30607       };
30608     }
30609   }
30610   jresult = (int)result;
30611   return jresult;
30612 }
30613
30614
30615 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
30616   unsigned int jresult ;
30617   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30618   bool result;
30619
30620   arg1 = (Dali::Actor *)jarg1;
30621   {
30622     try {
30623       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
30624     } catch (std::out_of_range& e) {
30625       {
30626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30627       };
30628     } catch (std::exception& e) {
30629       {
30630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30631       };
30632     } catch (...) {
30633       {
30634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30635       };
30636     }
30637   }
30638   jresult = result;
30639   return jresult;
30640 }
30641
30642
30643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30644   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30645   Dali::Degree *arg2 = 0 ;
30646   Dali::Vector3 *arg3 = 0 ;
30647
30648   arg1 = (Dali::Actor *)jarg1;
30649   arg2 = (Dali::Degree *)jarg2;
30650   if (!arg2) {
30651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30652     return ;
30653   }
30654   arg3 = (Dali::Vector3 *)jarg3;
30655   if (!arg3) {
30656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30657     return ;
30658   }
30659   {
30660     try {
30661       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30662     } catch (std::out_of_range& e) {
30663       {
30664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30665       };
30666     } catch (std::exception& e) {
30667       {
30668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30669       };
30670     } catch (...) {
30671       {
30672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30673       };
30674     }
30675   }
30676 }
30677
30678
30679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30680   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30681   Dali::Radian *arg2 = 0 ;
30682   Dali::Vector3 *arg3 = 0 ;
30683
30684   arg1 = (Dali::Actor *)jarg1;
30685   arg2 = (Dali::Radian *)jarg2;
30686   if (!arg2) {
30687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30688     return ;
30689   }
30690   arg3 = (Dali::Vector3 *)jarg3;
30691   if (!arg3) {
30692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30693     return ;
30694   }
30695   {
30696     try {
30697       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30698     } catch (std::out_of_range& e) {
30699       {
30700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30701       };
30702     } catch (std::exception& e) {
30703       {
30704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30705       };
30706     } catch (...) {
30707       {
30708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30709       };
30710     }
30711   }
30712 }
30713
30714
30715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
30716   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30717   Dali::Quaternion *arg2 = 0 ;
30718
30719   arg1 = (Dali::Actor *)jarg1;
30720   arg2 = (Dali::Quaternion *)jarg2;
30721   if (!arg2) {
30722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30723     return ;
30724   }
30725   {
30726     try {
30727       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
30728     } catch (std::out_of_range& e) {
30729       {
30730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30731       };
30732     } catch (std::exception& e) {
30733       {
30734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30735       };
30736     } catch (...) {
30737       {
30738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30739       };
30740     }
30741   }
30742 }
30743
30744
30745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30746   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30747   Dali::Degree *arg2 = 0 ;
30748   Dali::Vector3 *arg3 = 0 ;
30749
30750   arg1 = (Dali::Actor *)jarg1;
30751   arg2 = (Dali::Degree *)jarg2;
30752   if (!arg2) {
30753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30754     return ;
30755   }
30756   arg3 = (Dali::Vector3 *)jarg3;
30757   if (!arg3) {
30758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30759     return ;
30760   }
30761   {
30762     try {
30763       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30764     } catch (std::out_of_range& e) {
30765       {
30766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30767       };
30768     } catch (std::exception& e) {
30769       {
30770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30771       };
30772     } catch (...) {
30773       {
30774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30775       };
30776     }
30777   }
30778 }
30779
30780
30781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30782   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30783   Dali::Radian *arg2 = 0 ;
30784   Dali::Vector3 *arg3 = 0 ;
30785
30786   arg1 = (Dali::Actor *)jarg1;
30787   arg2 = (Dali::Radian *)jarg2;
30788   if (!arg2) {
30789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30790     return ;
30791   }
30792   arg3 = (Dali::Vector3 *)jarg3;
30793   if (!arg3) {
30794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30795     return ;
30796   }
30797   {
30798     try {
30799       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30800     } catch (std::out_of_range& e) {
30801       {
30802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30803       };
30804     } catch (std::exception& e) {
30805       {
30806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30807       };
30808     } catch (...) {
30809       {
30810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30811       };
30812     }
30813   }
30814 }
30815
30816
30817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
30818   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30819   Dali::Quaternion *arg2 = 0 ;
30820
30821   arg1 = (Dali::Actor *)jarg1;
30822   arg2 = (Dali::Quaternion *)jarg2;
30823   if (!arg2) {
30824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30825     return ;
30826   }
30827   {
30828     try {
30829       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
30830     } catch (std::out_of_range& e) {
30831       {
30832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30833       };
30834     } catch (std::exception& e) {
30835       {
30836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30837       };
30838     } catch (...) {
30839       {
30840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30841       };
30842     }
30843   }
30844 }
30845
30846
30847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
30848   void * jresult ;
30849   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30850   Dali::Quaternion result;
30851
30852   arg1 = (Dali::Actor *)jarg1;
30853   {
30854     try {
30855       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
30856     } catch (std::out_of_range& e) {
30857       {
30858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30859       };
30860     } catch (std::exception& e) {
30861       {
30862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30863       };
30864     } catch (...) {
30865       {
30866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30867       };
30868     }
30869   }
30870   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30871   return jresult;
30872 }
30873
30874
30875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
30876   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30877   bool arg2 ;
30878
30879   arg1 = (Dali::Actor *)jarg1;
30880   arg2 = jarg2 ? true : false;
30881   {
30882     try {
30883       (arg1)->SetInheritOrientation(arg2);
30884     } catch (std::out_of_range& e) {
30885       {
30886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30887       };
30888     } catch (std::exception& e) {
30889       {
30890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30891       };
30892     } catch (...) {
30893       {
30894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30895       };
30896     }
30897   }
30898 }
30899
30900
30901 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
30902   unsigned int jresult ;
30903   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30904   bool result;
30905
30906   arg1 = (Dali::Actor *)jarg1;
30907   {
30908     try {
30909       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
30910     } catch (std::out_of_range& e) {
30911       {
30912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30913       };
30914     } catch (std::exception& e) {
30915       {
30916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30917       };
30918     } catch (...) {
30919       {
30920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30921       };
30922     }
30923   }
30924   jresult = result;
30925   return jresult;
30926 }
30927
30928
30929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
30930   void * jresult ;
30931   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30932   Dali::Quaternion result;
30933
30934   arg1 = (Dali::Actor *)jarg1;
30935   {
30936     try {
30937       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
30938     } catch (std::out_of_range& e) {
30939       {
30940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30941       };
30942     } catch (std::exception& e) {
30943       {
30944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30945       };
30946     } catch (...) {
30947       {
30948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30949       };
30950     }
30951   }
30952   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30953   return jresult;
30954 }
30955
30956
30957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
30958   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30959   float arg2 ;
30960
30961   arg1 = (Dali::Actor *)jarg1;
30962   arg2 = (float)jarg2;
30963   {
30964     try {
30965       (arg1)->SetScale(arg2);
30966     } catch (std::out_of_range& e) {
30967       {
30968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30969       };
30970     } catch (std::exception& e) {
30971       {
30972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30973       };
30974     } catch (...) {
30975       {
30976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30977       };
30978     }
30979   }
30980 }
30981
30982
30983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30984   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30985   float arg2 ;
30986   float arg3 ;
30987   float arg4 ;
30988
30989   arg1 = (Dali::Actor *)jarg1;
30990   arg2 = (float)jarg2;
30991   arg3 = (float)jarg3;
30992   arg4 = (float)jarg4;
30993   {
30994     try {
30995       (arg1)->SetScale(arg2,arg3,arg4);
30996     } catch (std::out_of_range& e) {
30997       {
30998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30999       };
31000     } catch (std::exception& e) {
31001       {
31002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31003       };
31004     } catch (...) {
31005       {
31006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31007       };
31008     }
31009   }
31010 }
31011
31012
31013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
31014   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31015   Dali::Vector3 *arg2 = 0 ;
31016
31017   arg1 = (Dali::Actor *)jarg1;
31018   arg2 = (Dali::Vector3 *)jarg2;
31019   if (!arg2) {
31020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
31021     return ;
31022   }
31023   {
31024     try {
31025       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
31026     } catch (std::out_of_range& e) {
31027       {
31028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31029       };
31030     } catch (std::exception& e) {
31031       {
31032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31033       };
31034     } catch (...) {
31035       {
31036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31037       };
31038     }
31039   }
31040 }
31041
31042
31043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
31044   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31045   Dali::Vector3 *arg2 = 0 ;
31046
31047   arg1 = (Dali::Actor *)jarg1;
31048   arg2 = (Dali::Vector3 *)jarg2;
31049   if (!arg2) {
31050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
31051     return ;
31052   }
31053   {
31054     try {
31055       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
31056     } catch (std::out_of_range& e) {
31057       {
31058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31059       };
31060     } catch (std::exception& e) {
31061       {
31062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31063       };
31064     } catch (...) {
31065       {
31066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31067       };
31068     }
31069   }
31070 }
31071
31072
31073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
31074   void * jresult ;
31075   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31076   Dali::Vector3 result;
31077
31078   arg1 = (Dali::Actor *)jarg1;
31079   {
31080     try {
31081       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
31082     } catch (std::out_of_range& e) {
31083       {
31084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31085       };
31086     } catch (std::exception& e) {
31087       {
31088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31089       };
31090     } catch (...) {
31091       {
31092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31093       };
31094     }
31095   }
31096   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31097   return jresult;
31098 }
31099
31100
31101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
31102   void * jresult ;
31103   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31104   Dali::Vector3 result;
31105
31106   arg1 = (Dali::Actor *)jarg1;
31107   {
31108     try {
31109       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
31110     } catch (std::out_of_range& e) {
31111       {
31112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31113       };
31114     } catch (std::exception& e) {
31115       {
31116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31117       };
31118     } catch (...) {
31119       {
31120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31121       };
31122     }
31123   }
31124   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31125   return jresult;
31126 }
31127
31128
31129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
31130   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31131   bool arg2 ;
31132
31133   arg1 = (Dali::Actor *)jarg1;
31134   arg2 = jarg2 ? true : false;
31135   {
31136     try {
31137       (arg1)->SetInheritScale(arg2);
31138     } catch (std::out_of_range& e) {
31139       {
31140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31141       };
31142     } catch (std::exception& e) {
31143       {
31144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31145       };
31146     } catch (...) {
31147       {
31148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31149       };
31150     }
31151   }
31152 }
31153
31154
31155 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
31156   unsigned int jresult ;
31157   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31158   bool result;
31159
31160   arg1 = (Dali::Actor *)jarg1;
31161   {
31162     try {
31163       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
31164     } catch (std::out_of_range& e) {
31165       {
31166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31167       };
31168     } catch (std::exception& e) {
31169       {
31170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31171       };
31172     } catch (...) {
31173       {
31174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31175       };
31176     }
31177   }
31178   jresult = result;
31179   return jresult;
31180 }
31181
31182
31183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
31184   void * jresult ;
31185   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31186   Dali::Matrix result;
31187
31188   arg1 = (Dali::Actor *)jarg1;
31189   {
31190     try {
31191       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
31192     } catch (std::out_of_range& e) {
31193       {
31194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31195       };
31196     } catch (std::exception& e) {
31197       {
31198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31199       };
31200     } catch (...) {
31201       {
31202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31203       };
31204     }
31205   }
31206   jresult = new Dali::Matrix((const Dali::Matrix &)result);
31207   return jresult;
31208 }
31209
31210
31211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
31212   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31213   bool arg2 ;
31214
31215   arg1 = (Dali::Actor *)jarg1;
31216   arg2 = jarg2 ? true : false;
31217   {
31218     try {
31219       (arg1)->SetVisible(arg2);
31220     } catch (std::out_of_range& e) {
31221       {
31222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31223       };
31224     } catch (std::exception& e) {
31225       {
31226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31227       };
31228     } catch (...) {
31229       {
31230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31231       };
31232     }
31233   }
31234 }
31235
31236
31237 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
31238   unsigned int jresult ;
31239   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31240   bool result;
31241
31242   arg1 = (Dali::Actor *)jarg1;
31243   {
31244     try {
31245       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
31246     } catch (std::out_of_range& e) {
31247       {
31248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31249       };
31250     } catch (std::exception& e) {
31251       {
31252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31253       };
31254     } catch (...) {
31255       {
31256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31257       };
31258     }
31259   }
31260   jresult = result;
31261   return jresult;
31262 }
31263
31264
31265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
31266   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31267   float arg2 ;
31268
31269   arg1 = (Dali::Actor *)jarg1;
31270   arg2 = (float)jarg2;
31271   {
31272     try {
31273       (arg1)->SetOpacity(arg2);
31274     } catch (std::out_of_range& e) {
31275       {
31276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31277       };
31278     } catch (std::exception& e) {
31279       {
31280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31281       };
31282     } catch (...) {
31283       {
31284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31285       };
31286     }
31287   }
31288 }
31289
31290
31291 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
31292   float jresult ;
31293   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31294   float result;
31295
31296   arg1 = (Dali::Actor *)jarg1;
31297   {
31298     try {
31299       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
31300     } catch (std::out_of_range& e) {
31301       {
31302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31303       };
31304     } catch (std::exception& e) {
31305       {
31306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31307       };
31308     } catch (...) {
31309       {
31310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31311       };
31312     }
31313   }
31314   jresult = result;
31315   return jresult;
31316 }
31317
31318
31319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
31320   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31321   Dali::Vector4 *arg2 = 0 ;
31322
31323   arg1 = (Dali::Actor *)jarg1;
31324   arg2 = (Dali::Vector4 *)jarg2;
31325   if (!arg2) {
31326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
31327     return ;
31328   }
31329   {
31330     try {
31331       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
31332     } catch (std::out_of_range& e) {
31333       {
31334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31335       };
31336     } catch (std::exception& e) {
31337       {
31338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31339       };
31340     } catch (...) {
31341       {
31342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31343       };
31344     }
31345   }
31346 }
31347
31348
31349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
31350   void * jresult ;
31351   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31352   Dali::Vector4 result;
31353
31354   arg1 = (Dali::Actor *)jarg1;
31355   {
31356     try {
31357       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
31358     } catch (std::out_of_range& e) {
31359       {
31360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31361       };
31362     } catch (std::exception& e) {
31363       {
31364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31365       };
31366     } catch (...) {
31367       {
31368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31369       };
31370     }
31371   }
31372   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31373   return jresult;
31374 }
31375
31376
31377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
31378   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31379   Dali::ColorMode arg2 ;
31380
31381   arg1 = (Dali::Actor *)jarg1;
31382   arg2 = (Dali::ColorMode)jarg2;
31383   {
31384     try {
31385       (arg1)->SetColorMode(arg2);
31386     } catch (std::out_of_range& e) {
31387       {
31388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31389       };
31390     } catch (std::exception& e) {
31391       {
31392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31393       };
31394     } catch (...) {
31395       {
31396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31397       };
31398     }
31399   }
31400 }
31401
31402
31403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
31404   int jresult ;
31405   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31406   Dali::ColorMode result;
31407
31408   arg1 = (Dali::Actor *)jarg1;
31409   {
31410     try {
31411       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
31412     } catch (std::out_of_range& e) {
31413       {
31414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31415       };
31416     } catch (std::exception& e) {
31417       {
31418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31419       };
31420     } catch (...) {
31421       {
31422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31423       };
31424     }
31425   }
31426   jresult = (int)result;
31427   return jresult;
31428 }
31429
31430
31431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
31432   void * jresult ;
31433   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31434   Dali::Vector4 result;
31435
31436   arg1 = (Dali::Actor *)jarg1;
31437   {
31438     try {
31439       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
31440     } catch (std::out_of_range& e) {
31441       {
31442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31443       };
31444     } catch (std::exception& e) {
31445       {
31446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31447       };
31448     } catch (...) {
31449       {
31450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31451       };
31452     }
31453   }
31454   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31455   return jresult;
31456 }
31457
31458
31459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
31460   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31461   Dali::DrawMode::Type arg2 ;
31462
31463   arg1 = (Dali::Actor *)jarg1;
31464   arg2 = (Dali::DrawMode::Type)jarg2;
31465   {
31466     try {
31467       (arg1)->SetDrawMode(arg2);
31468     } catch (std::out_of_range& e) {
31469       {
31470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31471       };
31472     } catch (std::exception& e) {
31473       {
31474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31475       };
31476     } catch (...) {
31477       {
31478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31479       };
31480     }
31481   }
31482 }
31483
31484
31485 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
31486   int jresult ;
31487   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31488   Dali::DrawMode::Type result;
31489
31490   arg1 = (Dali::Actor *)jarg1;
31491   {
31492     try {
31493       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
31494     } catch (std::out_of_range& e) {
31495       {
31496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31497       };
31498     } catch (std::exception& e) {
31499       {
31500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31501       };
31502     } catch (...) {
31503       {
31504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31505       };
31506     }
31507   }
31508   jresult = (int)result;
31509   return jresult;
31510 }
31511
31512
31513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
31514   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31515   bool arg2 ;
31516
31517   arg1 = (Dali::Actor *)jarg1;
31518   arg2 = jarg2 ? true : false;
31519   {
31520     try {
31521       (arg1)->SetSensitive(arg2);
31522     } catch (std::out_of_range& e) {
31523       {
31524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31525       };
31526     } catch (std::exception& e) {
31527       {
31528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31529       };
31530     } catch (...) {
31531       {
31532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31533       };
31534     }
31535   }
31536 }
31537
31538
31539 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
31540   unsigned int jresult ;
31541   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31542   bool result;
31543
31544   arg1 = (Dali::Actor *)jarg1;
31545   {
31546     try {
31547       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
31548     } catch (std::out_of_range& e) {
31549       {
31550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31551       };
31552     } catch (std::exception& e) {
31553       {
31554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31555       };
31556     } catch (...) {
31557       {
31558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31559       };
31560     }
31561   }
31562   jresult = result;
31563   return jresult;
31564 }
31565
31566
31567 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
31568   unsigned int jresult ;
31569   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31570   float *arg2 = 0 ;
31571   float *arg3 = 0 ;
31572   float arg4 ;
31573   float arg5 ;
31574   bool result;
31575
31576   arg1 = (Dali::Actor *)jarg1;
31577   arg2 = (float *)jarg2;
31578   arg3 = (float *)jarg3;
31579   arg4 = (float)jarg4;
31580   arg5 = (float)jarg5;
31581   {
31582     try {
31583       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
31584     } catch (std::out_of_range& e) {
31585       {
31586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31587       };
31588     } catch (std::exception& e) {
31589       {
31590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31591       };
31592     } catch (...) {
31593       {
31594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31595       };
31596     }
31597   }
31598   jresult = result;
31599   return jresult;
31600 }
31601
31602
31603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
31604   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31605   bool arg2 ;
31606
31607   arg1 = (Dali::Actor *)jarg1;
31608   arg2 = jarg2 ? true : false;
31609   {
31610     try {
31611       (arg1)->SetLeaveRequired(arg2);
31612     } catch (std::out_of_range& e) {
31613       {
31614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31615       };
31616     } catch (std::exception& e) {
31617       {
31618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31619       };
31620     } catch (...) {
31621       {
31622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31623       };
31624     }
31625   }
31626 }
31627
31628
31629 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
31630   unsigned int jresult ;
31631   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31632   bool result;
31633
31634   arg1 = (Dali::Actor *)jarg1;
31635   {
31636     try {
31637       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
31638     } catch (std::out_of_range& e) {
31639       {
31640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31641       };
31642     } catch (std::exception& e) {
31643       {
31644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31645       };
31646     } catch (...) {
31647       {
31648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31649       };
31650     }
31651   }
31652   jresult = result;
31653   return jresult;
31654 }
31655
31656
31657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
31658   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31659   bool arg2 ;
31660
31661   arg1 = (Dali::Actor *)jarg1;
31662   arg2 = jarg2 ? true : false;
31663   {
31664     try {
31665       (arg1)->SetKeyboardFocusable(arg2);
31666     } catch (std::out_of_range& e) {
31667       {
31668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31669       };
31670     } catch (std::exception& e) {
31671       {
31672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31673       };
31674     } catch (...) {
31675       {
31676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31677       };
31678     }
31679   }
31680 }
31681
31682
31683 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
31684   unsigned int jresult ;
31685   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31686   bool result;
31687
31688   arg1 = (Dali::Actor *)jarg1;
31689   {
31690     try {
31691       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
31692     } catch (std::out_of_range& e) {
31693       {
31694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31695       };
31696     } catch (std::exception& e) {
31697       {
31698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31699       };
31700     } catch (...) {
31701       {
31702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31703       };
31704     }
31705   }
31706   jresult = result;
31707   return jresult;
31708 }
31709
31710
31711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
31712   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31713   Dali::ResizePolicy::Type arg2 ;
31714   Dali::Dimension::Type arg3 ;
31715
31716   arg1 = (Dali::Actor *)jarg1;
31717   arg2 = (Dali::ResizePolicy::Type)jarg2;
31718   arg3 = (Dali::Dimension::Type)jarg3;
31719   {
31720     try {
31721       (arg1)->SetResizePolicy(arg2,arg3);
31722     } catch (std::out_of_range& e) {
31723       {
31724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31725       };
31726     } catch (std::exception& e) {
31727       {
31728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31729       };
31730     } catch (...) {
31731       {
31732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31733       };
31734     }
31735   }
31736 }
31737
31738
31739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
31740   int jresult ;
31741   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31742   Dali::Dimension::Type arg2 ;
31743   Dali::ResizePolicy::Type result;
31744
31745   arg1 = (Dali::Actor *)jarg1;
31746   arg2 = (Dali::Dimension::Type)jarg2;
31747   {
31748     try {
31749       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
31750     } catch (std::out_of_range& e) {
31751       {
31752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31753       };
31754     } catch (std::exception& e) {
31755       {
31756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31757       };
31758     } catch (...) {
31759       {
31760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31761       };
31762     }
31763   }
31764   jresult = (int)result;
31765   return jresult;
31766 }
31767
31768
31769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
31770   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31771   Dali::SizeScalePolicy::Type arg2 ;
31772
31773   arg1 = (Dali::Actor *)jarg1;
31774   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
31775   {
31776     try {
31777       (arg1)->SetSizeScalePolicy(arg2);
31778     } catch (std::out_of_range& e) {
31779       {
31780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31781       };
31782     } catch (std::exception& e) {
31783       {
31784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31785       };
31786     } catch (...) {
31787       {
31788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31789       };
31790     }
31791   }
31792 }
31793
31794
31795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
31796   int jresult ;
31797   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31798   Dali::SizeScalePolicy::Type result;
31799
31800   arg1 = (Dali::Actor *)jarg1;
31801   {
31802     try {
31803       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
31804     } catch (std::out_of_range& e) {
31805       {
31806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31807       };
31808     } catch (std::exception& e) {
31809       {
31810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31811       };
31812     } catch (...) {
31813       {
31814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31815       };
31816     }
31817   }
31818   jresult = (int)result;
31819   return jresult;
31820 }
31821
31822
31823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
31824   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31825   Dali::Vector3 *arg2 = 0 ;
31826
31827   arg1 = (Dali::Actor *)jarg1;
31828   arg2 = (Dali::Vector3 *)jarg2;
31829   if (!arg2) {
31830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
31831     return ;
31832   }
31833   {
31834     try {
31835       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
31836     } catch (std::out_of_range& e) {
31837       {
31838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31839       };
31840     } catch (std::exception& e) {
31841       {
31842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31843       };
31844     } catch (...) {
31845       {
31846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31847       };
31848     }
31849   }
31850 }
31851
31852
31853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
31854   void * jresult ;
31855   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31856   Dali::Vector3 result;
31857
31858   arg1 = (Dali::Actor *)jarg1;
31859   {
31860     try {
31861       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
31862     } catch (std::out_of_range& e) {
31863       {
31864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31865       };
31866     } catch (std::exception& e) {
31867       {
31868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31869       };
31870     } catch (...) {
31871       {
31872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31873       };
31874     }
31875   }
31876   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31877   return jresult;
31878 }
31879
31880
31881 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
31882   float jresult ;
31883   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31884   float arg2 ;
31885   float result;
31886
31887   arg1 = (Dali::Actor *)jarg1;
31888   arg2 = (float)jarg2;
31889   {
31890     try {
31891       result = (float)(arg1)->GetHeightForWidth(arg2);
31892     } catch (std::out_of_range& e) {
31893       {
31894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31895       };
31896     } catch (std::exception& e) {
31897       {
31898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31899       };
31900     } catch (...) {
31901       {
31902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31903       };
31904     }
31905   }
31906   jresult = result;
31907   return jresult;
31908 }
31909
31910
31911 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
31912   float jresult ;
31913   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31914   float arg2 ;
31915   float result;
31916
31917   arg1 = (Dali::Actor *)jarg1;
31918   arg2 = (float)jarg2;
31919   {
31920     try {
31921       result = (float)(arg1)->GetWidthForHeight(arg2);
31922     } catch (std::out_of_range& e) {
31923       {
31924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31925       };
31926     } catch (std::exception& e) {
31927       {
31928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31929       };
31930     } catch (...) {
31931       {
31932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31933       };
31934     }
31935   }
31936   jresult = result;
31937   return jresult;
31938 }
31939
31940
31941 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
31942   float jresult ;
31943   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31944   Dali::Dimension::Type arg2 ;
31945   float result;
31946
31947   arg1 = (Dali::Actor *)jarg1;
31948   arg2 = (Dali::Dimension::Type)jarg2;
31949   {
31950     try {
31951       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
31952     } catch (std::out_of_range& e) {
31953       {
31954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31955       };
31956     } catch (std::exception& e) {
31957       {
31958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31959       };
31960     } catch (...) {
31961       {
31962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31963       };
31964     }
31965   }
31966   jresult = result;
31967   return jresult;
31968 }
31969
31970
31971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
31972   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31973   Dali::Padding *arg2 = 0 ;
31974
31975   arg1 = (Dali::Actor *)jarg1;
31976   arg2 = (Dali::Padding *)jarg2;
31977   if (!arg2) {
31978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
31979     return ;
31980   }
31981   {
31982     try {
31983       (arg1)->SetPadding((Dali::Padding const &)*arg2);
31984     } catch (std::out_of_range& e) {
31985       {
31986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31987       };
31988     } catch (std::exception& e) {
31989       {
31990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31991       };
31992     } catch (...) {
31993       {
31994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31995       };
31996     }
31997   }
31998 }
31999
32000
32001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
32002   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32003   Dali::Padding *arg2 = 0 ;
32004
32005   arg1 = (Dali::Actor *)jarg1;
32006   arg2 = (Dali::Padding *)jarg2;
32007   if (!arg2) {
32008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
32009     return ;
32010   }
32011   {
32012     try {
32013       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
32014     } catch (std::out_of_range& e) {
32015       {
32016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32017       };
32018     } catch (std::exception& e) {
32019       {
32020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32021       };
32022     } catch (...) {
32023       {
32024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32025       };
32026     }
32027   }
32028 }
32029
32030
32031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
32032   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32033   Dali::Vector2 *arg2 = 0 ;
32034
32035   arg1 = (Dali::Actor *)jarg1;
32036   arg2 = (Dali::Vector2 *)jarg2;
32037   if (!arg2) {
32038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
32039     return ;
32040   }
32041   {
32042     try {
32043       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
32044     } catch (std::out_of_range& e) {
32045       {
32046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32047       };
32048     } catch (std::exception& e) {
32049       {
32050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32051       };
32052     } catch (...) {
32053       {
32054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32055       };
32056     }
32057   }
32058 }
32059
32060
32061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
32062   void * jresult ;
32063   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32064   Dali::Vector2 result;
32065
32066   arg1 = (Dali::Actor *)jarg1;
32067   {
32068     try {
32069       result = (arg1)->GetMinimumSize();
32070     } catch (std::out_of_range& e) {
32071       {
32072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32073       };
32074     } catch (std::exception& e) {
32075       {
32076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32077       };
32078     } catch (...) {
32079       {
32080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32081       };
32082     }
32083   }
32084   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
32085   return jresult;
32086 }
32087
32088
32089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
32090   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32091   Dali::Vector2 *arg2 = 0 ;
32092
32093   arg1 = (Dali::Actor *)jarg1;
32094   arg2 = (Dali::Vector2 *)jarg2;
32095   if (!arg2) {
32096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
32097     return ;
32098   }
32099   {
32100     try {
32101       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
32102     } catch (std::out_of_range& e) {
32103       {
32104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32105       };
32106     } catch (std::exception& e) {
32107       {
32108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32109       };
32110     } catch (...) {
32111       {
32112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32113       };
32114     }
32115   }
32116 }
32117
32118
32119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
32120   void * jresult ;
32121   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32122   Dali::Vector2 result;
32123
32124   arg1 = (Dali::Actor *)jarg1;
32125   {
32126     try {
32127       result = (arg1)->GetMaximumSize();
32128     } catch (std::out_of_range& e) {
32129       {
32130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32131       };
32132     } catch (std::exception& e) {
32133       {
32134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32135       };
32136     } catch (...) {
32137       {
32138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32139       };
32140     }
32141   }
32142   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
32143   return jresult;
32144 }
32145
32146
32147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
32148   int jresult ;
32149   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32150   int result;
32151
32152   arg1 = (Dali::Actor *)jarg1;
32153   {
32154     try {
32155       result = (int)(arg1)->GetHierarchyDepth();
32156     } catch (std::out_of_range& e) {
32157       {
32158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32159       };
32160     } catch (std::exception& e) {
32161       {
32162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32163       };
32164     } catch (...) {
32165       {
32166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32167       };
32168     }
32169   }
32170   jresult = result;
32171   return jresult;
32172 }
32173
32174
32175 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
32176   unsigned int jresult ;
32177   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32178   Dali::Renderer *arg2 = 0 ;
32179   unsigned int result;
32180
32181   arg1 = (Dali::Actor *)jarg1;
32182   arg2 = (Dali::Renderer *)jarg2;
32183   if (!arg2) {
32184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
32185     return 0;
32186   }
32187   {
32188     try {
32189       result = (unsigned int)(arg1)->AddRenderer(*arg2);
32190     } catch (std::out_of_range& e) {
32191       {
32192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32193       };
32194     } catch (std::exception& e) {
32195       {
32196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32197       };
32198     } catch (...) {
32199       {
32200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32201       };
32202     }
32203   }
32204   jresult = result;
32205   return jresult;
32206 }
32207
32208
32209 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
32210   unsigned int jresult ;
32211   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32212   unsigned int result;
32213
32214   arg1 = (Dali::Actor *)jarg1;
32215   {
32216     try {
32217       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
32218     } catch (std::out_of_range& e) {
32219       {
32220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32221       };
32222     } catch (std::exception& e) {
32223       {
32224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32225       };
32226     } catch (...) {
32227       {
32228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32229       };
32230     }
32231   }
32232   jresult = result;
32233   return jresult;
32234 }
32235
32236
32237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
32238   void * jresult ;
32239   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32240   unsigned int arg2 ;
32241   Dali::Renderer result;
32242
32243   arg1 = (Dali::Actor *)jarg1;
32244   arg2 = (unsigned int)jarg2;
32245   {
32246     try {
32247       result = (arg1)->GetRendererAt(arg2);
32248     } catch (std::out_of_range& e) {
32249       {
32250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32251       };
32252     } catch (std::exception& e) {
32253       {
32254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32255       };
32256     } catch (...) {
32257       {
32258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32259       };
32260     }
32261   }
32262   jresult = new Dali::Renderer((const Dali::Renderer &)result);
32263   return jresult;
32264 }
32265
32266
32267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
32268   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32269   Dali::Renderer *arg2 = 0 ;
32270
32271   arg1 = (Dali::Actor *)jarg1;
32272   arg2 = (Dali::Renderer *)jarg2;
32273   if (!arg2) {
32274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
32275     return ;
32276   }
32277   {
32278     try {
32279       (arg1)->RemoveRenderer(*arg2);
32280     } catch (std::out_of_range& e) {
32281       {
32282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32283       };
32284     } catch (std::exception& e) {
32285       {
32286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32287       };
32288     } catch (...) {
32289       {
32290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32291       };
32292     }
32293   }
32294 }
32295
32296
32297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
32298   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32299   unsigned int arg2 ;
32300
32301   arg1 = (Dali::Actor *)jarg1;
32302   arg2 = (unsigned int)jarg2;
32303   {
32304     try {
32305       (arg1)->RemoveRenderer(arg2);
32306     } catch (std::out_of_range& e) {
32307       {
32308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32309       };
32310     } catch (std::exception& e) {
32311       {
32312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32313       };
32314     } catch (...) {
32315       {
32316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32317       };
32318     }
32319   }
32320 }
32321
32322
32323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
32324   void * jresult ;
32325   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32326   Dali::Actor::TouchSignalType *result = 0 ;
32327
32328   arg1 = (Dali::Actor *)jarg1;
32329   {
32330     try {
32331       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
32332     } catch (std::out_of_range& e) {
32333       {
32334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32335       };
32336     } catch (std::exception& e) {
32337       {
32338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32339       };
32340     } catch (...) {
32341       {
32342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32343       };
32344     }
32345   }
32346   jresult = (void *)result;
32347   return jresult;
32348 }
32349
32350
32351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
32352   void * jresult ;
32353   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32354   Dali::Actor::TouchDataSignalType *result = 0 ;
32355
32356   arg1 = (Dali::Actor *)jarg1;
32357   {
32358     try {
32359       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
32360     } catch (std::out_of_range& e) {
32361       {
32362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32363       };
32364     } catch (std::exception& e) {
32365       {
32366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32367       };
32368     } catch (...) {
32369       {
32370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32371       };
32372     }
32373   }
32374   jresult = (void *)result;
32375   return jresult;
32376 }
32377
32378
32379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
32380   void * jresult ;
32381   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32382   Dali::Actor::HoverSignalType *result = 0 ;
32383
32384   arg1 = (Dali::Actor *)jarg1;
32385   {
32386     try {
32387       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
32388     } catch (std::out_of_range& e) {
32389       {
32390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32391       };
32392     } catch (std::exception& e) {
32393       {
32394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32395       };
32396     } catch (...) {
32397       {
32398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32399       };
32400     }
32401   }
32402   jresult = (void *)result;
32403   return jresult;
32404 }
32405
32406
32407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
32408   void * jresult ;
32409   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32410   Dali::Actor::WheelEventSignalType *result = 0 ;
32411
32412   arg1 = (Dali::Actor *)jarg1;
32413   {
32414     try {
32415       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
32416     } catch (std::out_of_range& e) {
32417       {
32418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32419       };
32420     } catch (std::exception& e) {
32421       {
32422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32423       };
32424     } catch (...) {
32425       {
32426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32427       };
32428     }
32429   }
32430   jresult = (void *)result;
32431   return jresult;
32432 }
32433
32434
32435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
32436   void * jresult ;
32437   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32438   Dali::Actor::OnStageSignalType *result = 0 ;
32439
32440   arg1 = (Dali::Actor *)jarg1;
32441   {
32442     try {
32443       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
32444     } catch (std::out_of_range& e) {
32445       {
32446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32447       };
32448     } catch (std::exception& e) {
32449       {
32450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32451       };
32452     } catch (...) {
32453       {
32454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32455       };
32456     }
32457   }
32458   jresult = (void *)result;
32459   return jresult;
32460 }
32461
32462
32463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
32464   void * jresult ;
32465   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32466   Dali::Actor::OffStageSignalType *result = 0 ;
32467
32468   arg1 = (Dali::Actor *)jarg1;
32469   {
32470     try {
32471       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
32472     } catch (std::out_of_range& e) {
32473       {
32474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32475       };
32476     } catch (std::exception& e) {
32477       {
32478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32479       };
32480     } catch (...) {
32481       {
32482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32483       };
32484     }
32485   }
32486   jresult = (void *)result;
32487   return jresult;
32488 }
32489
32490
32491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
32492   void * jresult ;
32493   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32494   Dali::Actor::OnRelayoutSignalType *result = 0 ;
32495
32496   arg1 = (Dali::Actor *)jarg1;
32497   {
32498     try {
32499       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
32500     } catch (std::out_of_range& e) {
32501       {
32502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32503       };
32504     } catch (std::exception& e) {
32505       {
32506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32507       };
32508     } catch (...) {
32509       {
32510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32511       };
32512     }
32513   }
32514   jresult = (void *)result;
32515   return jresult;
32516 }
32517
32518
32519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
32520   Dali::Actor *arg1 = 0 ;
32521
32522   arg1 = (Dali::Actor *)jarg1;
32523   if (!arg1) {
32524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
32525     return ;
32526   }
32527   {
32528     try {
32529       Dali::UnparentAndReset(*arg1);
32530     } catch (std::out_of_range& e) {
32531       {
32532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32533       };
32534     } catch (std::exception& e) {
32535       {
32536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32537       };
32538     } catch (...) {
32539       {
32540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32541       };
32542     }
32543   }
32544 }
32545
32546
32547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
32548   int jresult ;
32549   int result;
32550
32551   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
32552   jresult = (int)result;
32553   return jresult;
32554 }
32555
32556
32557 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
32558   int jresult ;
32559   int result;
32560
32561   result = (int)Dali::Layer::Property::CLIPPING_BOX;
32562   jresult = (int)result;
32563   return jresult;
32564 }
32565
32566
32567 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
32568   int jresult ;
32569   int result;
32570
32571   result = (int)Dali::Layer::Property::BEHAVIOR;
32572   jresult = (int)result;
32573   return jresult;
32574 }
32575
32576
32577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
32578   void * jresult ;
32579   Dali::Layer::Property *result = 0 ;
32580
32581   {
32582     try {
32583       result = (Dali::Layer::Property *)new Dali::Layer::Property();
32584     } catch (std::out_of_range& e) {
32585       {
32586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32587       };
32588     } catch (std::exception& e) {
32589       {
32590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32591       };
32592     } catch (...) {
32593       {
32594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32595       };
32596     }
32597   }
32598   jresult = (void *)result;
32599   return jresult;
32600 }
32601
32602
32603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
32604   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
32605
32606   arg1 = (Dali::Layer::Property *)jarg1;
32607   {
32608     try {
32609       delete arg1;
32610     } catch (std::out_of_range& e) {
32611       {
32612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32613       };
32614     } catch (std::exception& e) {
32615       {
32616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32617       };
32618     } catch (...) {
32619       {
32620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32621       };
32622     }
32623   }
32624 }
32625
32626
32627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
32628   void * jresult ;
32629   Dali::Layer *result = 0 ;
32630
32631   {
32632     try {
32633       result = (Dali::Layer *)new Dali::Layer();
32634     } catch (std::out_of_range& e) {
32635       {
32636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32637       };
32638     } catch (std::exception& e) {
32639       {
32640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32641       };
32642     } catch (...) {
32643       {
32644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32645       };
32646     }
32647   }
32648   jresult = (void *)result;
32649   return jresult;
32650 }
32651
32652
32653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
32654   void * jresult ;
32655   Dali::Layer result;
32656
32657   {
32658     try {
32659       result = Dali::Layer::New();
32660     } catch (std::out_of_range& e) {
32661       {
32662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32663       };
32664     } catch (std::exception& e) {
32665       {
32666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32667       };
32668     } catch (...) {
32669       {
32670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32671       };
32672     }
32673   }
32674   jresult = new Dali::Layer((const Dali::Layer &)result);
32675   return jresult;
32676 }
32677
32678
32679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
32680   void * jresult ;
32681   Dali::BaseHandle arg1 ;
32682   Dali::BaseHandle *argp1 ;
32683   Dali::Layer result;
32684
32685   argp1 = (Dali::BaseHandle *)jarg1;
32686   if (!argp1) {
32687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
32688     return 0;
32689   }
32690   arg1 = *argp1;
32691   {
32692     try {
32693       result = Dali::Layer::DownCast(arg1);
32694     } catch (std::out_of_range& e) {
32695       {
32696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32697       };
32698     } catch (std::exception& e) {
32699       {
32700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32701       };
32702     } catch (...) {
32703       {
32704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32705       };
32706     }
32707   }
32708   jresult = new Dali::Layer((const Dali::Layer &)result);
32709   return jresult;
32710 }
32711
32712
32713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
32714   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32715
32716   arg1 = (Dali::Layer *)jarg1;
32717   {
32718     try {
32719       delete arg1;
32720     } catch (std::out_of_range& e) {
32721       {
32722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32723       };
32724     } catch (std::exception& e) {
32725       {
32726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32727       };
32728     } catch (...) {
32729       {
32730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32731       };
32732     }
32733   }
32734 }
32735
32736
32737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
32738   void * jresult ;
32739   Dali::Layer *arg1 = 0 ;
32740   Dali::Layer *result = 0 ;
32741
32742   arg1 = (Dali::Layer *)jarg1;
32743   if (!arg1) {
32744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32745     return 0;
32746   }
32747   {
32748     try {
32749       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
32750     } catch (std::out_of_range& e) {
32751       {
32752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32753       };
32754     } catch (std::exception& e) {
32755       {
32756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32757       };
32758     } catch (...) {
32759       {
32760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32761       };
32762     }
32763   }
32764   jresult = (void *)result;
32765   return jresult;
32766 }
32767
32768
32769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
32770   void * jresult ;
32771   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32772   Dali::Layer *arg2 = 0 ;
32773   Dali::Layer *result = 0 ;
32774
32775   arg1 = (Dali::Layer *)jarg1;
32776   arg2 = (Dali::Layer *)jarg2;
32777   if (!arg2) {
32778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32779     return 0;
32780   }
32781   {
32782     try {
32783       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
32784     } catch (std::out_of_range& e) {
32785       {
32786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32787       };
32788     } catch (std::exception& e) {
32789       {
32790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32791       };
32792     } catch (...) {
32793       {
32794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32795       };
32796     }
32797   }
32798   jresult = (void *)result;
32799   return jresult;
32800 }
32801
32802
32803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
32804   unsigned int jresult ;
32805   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32806   unsigned int result;
32807
32808   arg1 = (Dali::Layer *)jarg1;
32809   {
32810     try {
32811       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
32812     } catch (std::out_of_range& e) {
32813       {
32814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32815       };
32816     } catch (std::exception& e) {
32817       {
32818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32819       };
32820     } catch (...) {
32821       {
32822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32823       };
32824     }
32825   }
32826   jresult = result;
32827   return jresult;
32828 }
32829
32830
32831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
32832   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32833
32834   arg1 = (Dali::Layer *)jarg1;
32835   {
32836     try {
32837       (arg1)->Raise();
32838     } catch (std::out_of_range& e) {
32839       {
32840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32841       };
32842     } catch (std::exception& e) {
32843       {
32844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32845       };
32846     } catch (...) {
32847       {
32848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32849       };
32850     }
32851   }
32852 }
32853
32854
32855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
32856   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32857
32858   arg1 = (Dali::Layer *)jarg1;
32859   {
32860     try {
32861       (arg1)->Lower();
32862     } catch (std::out_of_range& e) {
32863       {
32864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32865       };
32866     } catch (std::exception& e) {
32867       {
32868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32869       };
32870     } catch (...) {
32871       {
32872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32873       };
32874     }
32875   }
32876 }
32877
32878
32879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
32880   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32881   Dali::Layer arg2 ;
32882   Dali::Layer *argp2 ;
32883
32884   arg1 = (Dali::Layer *)jarg1;
32885   argp2 = (Dali::Layer *)jarg2;
32886   if (!argp2) {
32887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32888     return ;
32889   }
32890   arg2 = *argp2;
32891   {
32892     try {
32893       (arg1)->RaiseAbove(arg2);
32894     } catch (std::out_of_range& e) {
32895       {
32896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32897       };
32898     } catch (std::exception& e) {
32899       {
32900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32901       };
32902     } catch (...) {
32903       {
32904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32905       };
32906     }
32907   }
32908 }
32909
32910
32911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
32912   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32913   Dali::Layer arg2 ;
32914   Dali::Layer *argp2 ;
32915
32916   arg1 = (Dali::Layer *)jarg1;
32917   argp2 = (Dali::Layer *)jarg2;
32918   if (!argp2) {
32919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32920     return ;
32921   }
32922   arg2 = *argp2;
32923   {
32924     try {
32925       (arg1)->LowerBelow(arg2);
32926     } catch (std::out_of_range& e) {
32927       {
32928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32929       };
32930     } catch (std::exception& e) {
32931       {
32932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32933       };
32934     } catch (...) {
32935       {
32936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32937       };
32938     }
32939   }
32940 }
32941
32942
32943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
32944   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32945
32946   arg1 = (Dali::Layer *)jarg1;
32947   {
32948     try {
32949       (arg1)->RaiseToTop();
32950     } catch (std::out_of_range& e) {
32951       {
32952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32953       };
32954     } catch (std::exception& e) {
32955       {
32956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32957       };
32958     } catch (...) {
32959       {
32960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32961       };
32962     }
32963   }
32964 }
32965
32966
32967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
32968   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32969
32970   arg1 = (Dali::Layer *)jarg1;
32971   {
32972     try {
32973       (arg1)->LowerToBottom();
32974     } catch (std::out_of_range& e) {
32975       {
32976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32977       };
32978     } catch (std::exception& e) {
32979       {
32980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32981       };
32982     } catch (...) {
32983       {
32984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32985       };
32986     }
32987   }
32988 }
32989
32990
32991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
32992   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32993   Dali::Layer arg2 ;
32994   Dali::Layer *argp2 ;
32995
32996   arg1 = (Dali::Layer *)jarg1;
32997   argp2 = (Dali::Layer *)jarg2;
32998   if (!argp2) {
32999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
33000     return ;
33001   }
33002   arg2 = *argp2;
33003   {
33004     try {
33005       (arg1)->MoveAbove(arg2);
33006     } catch (std::out_of_range& e) {
33007       {
33008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33009       };
33010     } catch (std::exception& e) {
33011       {
33012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33013       };
33014     } catch (...) {
33015       {
33016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33017       };
33018     }
33019   }
33020 }
33021
33022
33023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
33024   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33025   Dali::Layer arg2 ;
33026   Dali::Layer *argp2 ;
33027
33028   arg1 = (Dali::Layer *)jarg1;
33029   argp2 = (Dali::Layer *)jarg2;
33030   if (!argp2) {
33031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
33032     return ;
33033   }
33034   arg2 = *argp2;
33035   {
33036     try {
33037       (arg1)->MoveBelow(arg2);
33038     } catch (std::out_of_range& e) {
33039       {
33040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33041       };
33042     } catch (std::exception& e) {
33043       {
33044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33045       };
33046     } catch (...) {
33047       {
33048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33049       };
33050     }
33051   }
33052 }
33053
33054
33055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
33056   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33057   Dali::Layer::Behavior arg2 ;
33058
33059   arg1 = (Dali::Layer *)jarg1;
33060   arg2 = (Dali::Layer::Behavior)jarg2;
33061   {
33062     try {
33063       (arg1)->SetBehavior(arg2);
33064     } catch (std::out_of_range& e) {
33065       {
33066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33067       };
33068     } catch (std::exception& e) {
33069       {
33070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33071       };
33072     } catch (...) {
33073       {
33074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33075       };
33076     }
33077   }
33078 }
33079
33080
33081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
33082   int jresult ;
33083   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33084   Dali::Layer::Behavior result;
33085
33086   arg1 = (Dali::Layer *)jarg1;
33087   {
33088     try {
33089       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
33090     } catch (std::out_of_range& e) {
33091       {
33092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33093       };
33094     } catch (std::exception& e) {
33095       {
33096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33097       };
33098     } catch (...) {
33099       {
33100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33101       };
33102     }
33103   }
33104   jresult = (int)result;
33105   return jresult;
33106 }
33107
33108
33109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
33110   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33111   bool arg2 ;
33112
33113   arg1 = (Dali::Layer *)jarg1;
33114   arg2 = jarg2 ? true : false;
33115   {
33116     try {
33117       (arg1)->SetClipping(arg2);
33118     } catch (std::out_of_range& e) {
33119       {
33120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33121       };
33122     } catch (std::exception& e) {
33123       {
33124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33125       };
33126     } catch (...) {
33127       {
33128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33129       };
33130     }
33131   }
33132 }
33133
33134
33135 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
33136   unsigned int jresult ;
33137   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33138   bool result;
33139
33140   arg1 = (Dali::Layer *)jarg1;
33141   {
33142     try {
33143       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
33144     } catch (std::out_of_range& e) {
33145       {
33146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33147       };
33148     } catch (std::exception& e) {
33149       {
33150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33151       };
33152     } catch (...) {
33153       {
33154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33155       };
33156     }
33157   }
33158   jresult = result;
33159   return jresult;
33160 }
33161
33162
33163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
33164   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33165   int arg2 ;
33166   int arg3 ;
33167   int arg4 ;
33168   int arg5 ;
33169
33170   arg1 = (Dali::Layer *)jarg1;
33171   arg2 = (int)jarg2;
33172   arg3 = (int)jarg3;
33173   arg4 = (int)jarg4;
33174   arg5 = (int)jarg5;
33175   {
33176     try {
33177       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
33178     } catch (std::out_of_range& e) {
33179       {
33180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33181       };
33182     } catch (std::exception& e) {
33183       {
33184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33185       };
33186     } catch (...) {
33187       {
33188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33189       };
33190     }
33191   }
33192 }
33193
33194
33195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
33196   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33197   Dali::ClippingBox arg2 ;
33198   Dali::ClippingBox *argp2 ;
33199
33200   arg1 = (Dali::Layer *)jarg1;
33201   argp2 = (Dali::ClippingBox *)jarg2;
33202   if (!argp2) {
33203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
33204     return ;
33205   }
33206   arg2 = *argp2;
33207   {
33208     try {
33209       (arg1)->SetClippingBox(arg2);
33210     } catch (std::out_of_range& e) {
33211       {
33212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33213       };
33214     } catch (std::exception& e) {
33215       {
33216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33217       };
33218     } catch (...) {
33219       {
33220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33221       };
33222     }
33223   }
33224 }
33225
33226
33227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
33228   void * jresult ;
33229   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33230   Dali::ClippingBox result;
33231
33232   arg1 = (Dali::Layer *)jarg1;
33233   {
33234     try {
33235       result = ((Dali::Layer const *)arg1)->GetClippingBox();
33236     } catch (std::out_of_range& e) {
33237       {
33238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33239       };
33240     } catch (std::exception& e) {
33241       {
33242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33243       };
33244     } catch (...) {
33245       {
33246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33247       };
33248     }
33249   }
33250   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
33251   return jresult;
33252 }
33253
33254
33255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
33256   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33257   bool arg2 ;
33258
33259   arg1 = (Dali::Layer *)jarg1;
33260   arg2 = jarg2 ? true : false;
33261   {
33262     try {
33263       (arg1)->SetDepthTestDisabled(arg2);
33264     } catch (std::out_of_range& e) {
33265       {
33266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33267       };
33268     } catch (std::exception& e) {
33269       {
33270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33271       };
33272     } catch (...) {
33273       {
33274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33275       };
33276     }
33277   }
33278 }
33279
33280
33281 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
33282   unsigned int jresult ;
33283   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33284   bool result;
33285
33286   arg1 = (Dali::Layer *)jarg1;
33287   {
33288     try {
33289       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
33290     } catch (std::out_of_range& e) {
33291       {
33292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33293       };
33294     } catch (std::exception& e) {
33295       {
33296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33297       };
33298     } catch (...) {
33299       {
33300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33301       };
33302     }
33303   }
33304   jresult = result;
33305   return jresult;
33306 }
33307
33308
33309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
33310   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33311   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
33312
33313   arg1 = (Dali::Layer *)jarg1;
33314   arg2 = (Dali::Layer::SortFunctionType)jarg2;
33315   {
33316     try {
33317       (arg1)->SetSortFunction(arg2);
33318     } catch (std::out_of_range& e) {
33319       {
33320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33321       };
33322     } catch (std::exception& e) {
33323       {
33324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33325       };
33326     } catch (...) {
33327       {
33328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33329       };
33330     }
33331   }
33332 }
33333
33334
33335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
33336   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33337   bool arg2 ;
33338
33339   arg1 = (Dali::Layer *)jarg1;
33340   arg2 = jarg2 ? true : false;
33341   {
33342     try {
33343       (arg1)->SetTouchConsumed(arg2);
33344     } catch (std::out_of_range& e) {
33345       {
33346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33347       };
33348     } catch (std::exception& e) {
33349       {
33350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33351       };
33352     } catch (...) {
33353       {
33354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33355       };
33356     }
33357   }
33358 }
33359
33360
33361 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
33362   unsigned int jresult ;
33363   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33364   bool result;
33365
33366   arg1 = (Dali::Layer *)jarg1;
33367   {
33368     try {
33369       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
33370     } catch (std::out_of_range& e) {
33371       {
33372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33373       };
33374     } catch (std::exception& e) {
33375       {
33376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33377       };
33378     } catch (...) {
33379       {
33380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33381       };
33382     }
33383   }
33384   jresult = result;
33385   return jresult;
33386 }
33387
33388
33389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
33390   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33391   bool arg2 ;
33392
33393   arg1 = (Dali::Layer *)jarg1;
33394   arg2 = jarg2 ? true : false;
33395   {
33396     try {
33397       (arg1)->SetHoverConsumed(arg2);
33398     } catch (std::out_of_range& e) {
33399       {
33400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33401       };
33402     } catch (std::exception& e) {
33403       {
33404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33405       };
33406     } catch (...) {
33407       {
33408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33409       };
33410     }
33411   }
33412 }
33413
33414
33415 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
33416   unsigned int jresult ;
33417   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33418   bool result;
33419
33420   arg1 = (Dali::Layer *)jarg1;
33421   {
33422     try {
33423       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
33424     } catch (std::out_of_range& e) {
33425       {
33426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33427       };
33428     } catch (std::exception& e) {
33429       {
33430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33431       };
33432     } catch (...) {
33433       {
33434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33435       };
33436     }
33437   }
33438   jresult = result;
33439   return jresult;
33440 }
33441
33442
33443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
33444   void * jresult ;
33445   Dali::Vector4 *result = 0 ;
33446
33447   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
33448   jresult = (void *)result;
33449   return jresult;
33450 }
33451
33452
33453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
33454   void * jresult ;
33455   Dali::Vector4 *result = 0 ;
33456
33457   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
33458   jresult = (void *)result;
33459   return jresult;
33460 }
33461
33462
33463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
33464   void * jresult ;
33465   Dali::Stage *result = 0 ;
33466
33467   {
33468     try {
33469       result = (Dali::Stage *)new Dali::Stage();
33470     } catch (std::out_of_range& e) {
33471       {
33472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33473       };
33474     } catch (std::exception& e) {
33475       {
33476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33477       };
33478     } catch (...) {
33479       {
33480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33481       };
33482     }
33483   }
33484   jresult = (void *)result;
33485   return jresult;
33486 }
33487
33488
33489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
33490   void * jresult ;
33491   Dali::Stage result;
33492
33493   {
33494     try {
33495       result = Dali::Stage::GetCurrent();
33496     } catch (std::out_of_range& e) {
33497       {
33498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33499       };
33500     } catch (std::exception& e) {
33501       {
33502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33503       };
33504     } catch (...) {
33505       {
33506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33507       };
33508     }
33509   }
33510   jresult = new Dali::Stage((const Dali::Stage &)result);
33511   return jresult;
33512 }
33513
33514
33515 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
33516   unsigned int jresult ;
33517   bool result;
33518
33519   {
33520     try {
33521       result = (bool)Dali::Stage::IsInstalled();
33522     } catch (std::out_of_range& e) {
33523       {
33524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33525       };
33526     } catch (std::exception& e) {
33527       {
33528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33529       };
33530     } catch (...) {
33531       {
33532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33533       };
33534     }
33535   }
33536   jresult = result;
33537   return jresult;
33538 }
33539
33540
33541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
33542   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33543
33544   arg1 = (Dali::Stage *)jarg1;
33545   {
33546     try {
33547       delete arg1;
33548     } catch (std::out_of_range& e) {
33549       {
33550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33551       };
33552     } catch (std::exception& e) {
33553       {
33554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33555       };
33556     } catch (...) {
33557       {
33558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33559       };
33560     }
33561   }
33562 }
33563
33564
33565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
33566   void * jresult ;
33567   Dali::Stage *arg1 = 0 ;
33568   Dali::Stage *result = 0 ;
33569
33570   arg1 = (Dali::Stage *)jarg1;
33571   if (!arg1) {
33572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33573     return 0;
33574   }
33575   {
33576     try {
33577       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
33578     } catch (std::out_of_range& e) {
33579       {
33580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33581       };
33582     } catch (std::exception& e) {
33583       {
33584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33585       };
33586     } catch (...) {
33587       {
33588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33589       };
33590     }
33591   }
33592   jresult = (void *)result;
33593   return jresult;
33594 }
33595
33596
33597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
33598   void * jresult ;
33599   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33600   Dali::Stage *arg2 = 0 ;
33601   Dali::Stage *result = 0 ;
33602
33603   arg1 = (Dali::Stage *)jarg1;
33604   arg2 = (Dali::Stage *)jarg2;
33605   if (!arg2) {
33606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33607     return 0;
33608   }
33609   {
33610     try {
33611       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
33612     } catch (std::out_of_range& e) {
33613       {
33614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33615       };
33616     } catch (std::exception& e) {
33617       {
33618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33619       };
33620     } catch (...) {
33621       {
33622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33623       };
33624     }
33625   }
33626   jresult = (void *)result;
33627   return jresult;
33628 }
33629
33630
33631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
33632   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33633   Dali::Actor *arg2 = 0 ;
33634
33635   arg1 = (Dali::Stage *)jarg1;
33636   arg2 = (Dali::Actor *)jarg2;
33637   if (!arg2) {
33638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33639     return ;
33640   }
33641   {
33642     try {
33643       (arg1)->Add(*arg2);
33644     } catch (std::out_of_range& e) {
33645       {
33646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33647       };
33648     } catch (std::exception& e) {
33649       {
33650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33651       };
33652     } catch (...) {
33653       {
33654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33655       };
33656     }
33657   }
33658 }
33659
33660
33661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
33662   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33663   Dali::Actor *arg2 = 0 ;
33664
33665   arg1 = (Dali::Stage *)jarg1;
33666   arg2 = (Dali::Actor *)jarg2;
33667   if (!arg2) {
33668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33669     return ;
33670   }
33671   {
33672     try {
33673       (arg1)->Remove(*arg2);
33674     } catch (std::out_of_range& e) {
33675       {
33676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33677       };
33678     } catch (std::exception& e) {
33679       {
33680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33681       };
33682     } catch (...) {
33683       {
33684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33685       };
33686     }
33687   }
33688 }
33689
33690
33691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
33692   void * jresult ;
33693   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33694   Dali::Vector2 result;
33695
33696   arg1 = (Dali::Stage *)jarg1;
33697   {
33698     try {
33699       result = ((Dali::Stage const *)arg1)->GetSize();
33700     } catch (std::out_of_range& e) {
33701       {
33702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33703       };
33704     } catch (std::exception& e) {
33705       {
33706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33707       };
33708     } catch (...) {
33709       {
33710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33711       };
33712     }
33713   }
33714   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33715   return jresult;
33716 }
33717
33718
33719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
33720   void * jresult ;
33721   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33722   Dali::RenderTaskList result;
33723
33724   arg1 = (Dali::Stage *)jarg1;
33725   {
33726     try {
33727       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
33728     } catch (std::out_of_range& e) {
33729       {
33730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33731       };
33732     } catch (std::exception& e) {
33733       {
33734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33735       };
33736     } catch (...) {
33737       {
33738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33739       };
33740     }
33741   }
33742   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
33743   return jresult;
33744 }
33745
33746
33747 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
33748   unsigned int jresult ;
33749   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33750   unsigned int result;
33751
33752   arg1 = (Dali::Stage *)jarg1;
33753   {
33754     try {
33755       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
33756     } catch (std::out_of_range& e) {
33757       {
33758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33759       };
33760     } catch (std::exception& e) {
33761       {
33762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33763       };
33764     } catch (...) {
33765       {
33766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33767       };
33768     }
33769   }
33770   jresult = result;
33771   return jresult;
33772 }
33773
33774
33775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
33776   void * jresult ;
33777   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33778   unsigned int arg2 ;
33779   Dali::Layer result;
33780
33781   arg1 = (Dali::Stage *)jarg1;
33782   arg2 = (unsigned int)jarg2;
33783   {
33784     try {
33785       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
33786     } catch (std::out_of_range& e) {
33787       {
33788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33789       };
33790     } catch (std::exception& e) {
33791       {
33792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33793       };
33794     } catch (...) {
33795       {
33796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33797       };
33798     }
33799   }
33800   jresult = new Dali::Layer((const Dali::Layer &)result);
33801   return jresult;
33802 }
33803
33804
33805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
33806   void * jresult ;
33807   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33808   Dali::Layer result;
33809
33810   arg1 = (Dali::Stage *)jarg1;
33811   {
33812     try {
33813       result = ((Dali::Stage const *)arg1)->GetRootLayer();
33814     } catch (std::out_of_range& e) {
33815       {
33816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33817       };
33818     } catch (std::exception& e) {
33819       {
33820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33821       };
33822     } catch (...) {
33823       {
33824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33825       };
33826     }
33827   }
33828   jresult = new Dali::Layer((const Dali::Layer &)result);
33829   return jresult;
33830 }
33831
33832
33833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
33834   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33835   Dali::Vector4 arg2 ;
33836   Dali::Vector4 *argp2 ;
33837
33838   arg1 = (Dali::Stage *)jarg1;
33839   argp2 = (Dali::Vector4 *)jarg2;
33840   if (!argp2) {
33841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
33842     return ;
33843   }
33844   arg2 = *argp2;
33845   {
33846     try {
33847       (arg1)->SetBackgroundColor(arg2);
33848     } catch (std::out_of_range& e) {
33849       {
33850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33851       };
33852     } catch (std::exception& e) {
33853       {
33854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33855       };
33856     } catch (...) {
33857       {
33858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33859       };
33860     }
33861   }
33862 }
33863
33864
33865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
33866   void * jresult ;
33867   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33868   Dali::Vector4 result;
33869
33870   arg1 = (Dali::Stage *)jarg1;
33871   {
33872     try {
33873       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
33874     } catch (std::out_of_range& e) {
33875       {
33876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33877       };
33878     } catch (std::exception& e) {
33879       {
33880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33881       };
33882     } catch (...) {
33883       {
33884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33885       };
33886     }
33887   }
33888   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
33889   return jresult;
33890 }
33891
33892
33893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
33894   void * jresult ;
33895   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33896   Dali::Vector2 result;
33897
33898   arg1 = (Dali::Stage *)jarg1;
33899   {
33900     try {
33901       result = ((Dali::Stage const *)arg1)->GetDpi();
33902     } catch (std::out_of_range& e) {
33903       {
33904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33905       };
33906     } catch (std::exception& e) {
33907       {
33908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33909       };
33910     } catch (...) {
33911       {
33912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33913       };
33914     }
33915   }
33916   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33917   return jresult;
33918 }
33919
33920
33921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
33922   void * jresult ;
33923   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33924   Dali::ObjectRegistry result;
33925
33926   arg1 = (Dali::Stage *)jarg1;
33927   {
33928     try {
33929       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
33930     } catch (std::out_of_range& e) {
33931       {
33932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33933       };
33934     } catch (std::exception& e) {
33935       {
33936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33937       };
33938     } catch (...) {
33939       {
33940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33941       };
33942     }
33943   }
33944   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
33945   return jresult;
33946 }
33947
33948
33949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
33950   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33951   float arg2 ;
33952
33953   arg1 = (Dali::Stage *)jarg1;
33954   arg2 = (float)jarg2;
33955   {
33956     try {
33957       (arg1)->KeepRendering(arg2);
33958     } catch (std::out_of_range& e) {
33959       {
33960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33961       };
33962     } catch (std::exception& e) {
33963       {
33964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33965       };
33966     } catch (...) {
33967       {
33968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33969       };
33970     }
33971   }
33972 }
33973
33974
33975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
33976   void * jresult ;
33977   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33978   Dali::Stage::KeyEventSignalType *result = 0 ;
33979
33980   arg1 = (Dali::Stage *)jarg1;
33981   {
33982     try {
33983       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
33984     } catch (std::out_of_range& e) {
33985       {
33986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33987       };
33988     } catch (std::exception& e) {
33989       {
33990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33991       };
33992     } catch (...) {
33993       {
33994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33995       };
33996     }
33997   }
33998   jresult = (void *)result;
33999   return jresult;
34000 }
34001
34002
34003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
34004   void * jresult ;
34005   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34006   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
34007
34008   arg1 = (Dali::Stage *)jarg1;
34009   {
34010     try {
34011       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
34012     } catch (std::out_of_range& e) {
34013       {
34014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34015       };
34016     } catch (std::exception& e) {
34017       {
34018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34019       };
34020     } catch (...) {
34021       {
34022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34023       };
34024     }
34025   }
34026   jresult = (void *)result;
34027   return jresult;
34028 }
34029
34030
34031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
34032   void * jresult ;
34033   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34034   Dali::Stage::TouchSignalType *result = 0 ;
34035
34036   arg1 = (Dali::Stage *)jarg1;
34037   {
34038     try {
34039       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
34040     } catch (std::out_of_range& e) {
34041       {
34042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34043       };
34044     } catch (std::exception& e) {
34045       {
34046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34047       };
34048     } catch (...) {
34049       {
34050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34051       };
34052     }
34053   }
34054   jresult = (void *)result;
34055   return jresult;
34056 }
34057
34058
34059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
34060   void * jresult ;
34061   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34062   Dali::Stage::WheelEventSignalType *result = 0 ;
34063
34064   arg1 = (Dali::Stage *)jarg1;
34065   {
34066     try {
34067       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
34068     } catch (std::out_of_range& e) {
34069       {
34070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34071       };
34072     } catch (std::exception& e) {
34073       {
34074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34075       };
34076     } catch (...) {
34077       {
34078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34079       };
34080     }
34081   }
34082   jresult = (void *)result;
34083   return jresult;
34084 }
34085
34086
34087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
34088   void * jresult ;
34089   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34090   Dali::Stage::ContextStatusSignal *result = 0 ;
34091
34092   arg1 = (Dali::Stage *)jarg1;
34093   {
34094     try {
34095       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
34096     } catch (std::out_of_range& e) {
34097       {
34098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34099       };
34100     } catch (std::exception& e) {
34101       {
34102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34103       };
34104     } catch (...) {
34105       {
34106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34107       };
34108     }
34109   }
34110   jresult = (void *)result;
34111   return jresult;
34112 }
34113
34114
34115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
34116   void * jresult ;
34117   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34118   Dali::Stage::ContextStatusSignal *result = 0 ;
34119
34120   arg1 = (Dali::Stage *)jarg1;
34121   {
34122     try {
34123       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
34124     } catch (std::out_of_range& e) {
34125       {
34126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34127       };
34128     } catch (std::exception& e) {
34129       {
34130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34131       };
34132     } catch (...) {
34133       {
34134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34135       };
34136     }
34137   }
34138   jresult = (void *)result;
34139   return jresult;
34140 }
34141
34142
34143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
34144   void * jresult ;
34145   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34146   Dali::Stage::SceneCreatedSignalType *result = 0 ;
34147
34148   arg1 = (Dali::Stage *)jarg1;
34149   {
34150     try {
34151       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
34152     } catch (std::out_of_range& e) {
34153       {
34154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34155       };
34156     } catch (std::exception& e) {
34157       {
34158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34159       };
34160     } catch (...) {
34161       {
34162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34163       };
34164     }
34165   }
34166   jresult = (void *)result;
34167   return jresult;
34168 }
34169
34170
34171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
34172   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
34173
34174   arg1 = (Dali::RelayoutContainer *)jarg1;
34175   {
34176     try {
34177       delete arg1;
34178     } catch (std::out_of_range& e) {
34179       {
34180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34181       };
34182     } catch (std::exception& e) {
34183       {
34184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34185       };
34186     } catch (...) {
34187       {
34188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34189       };
34190     }
34191   }
34192 }
34193
34194
34195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
34196   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
34197   Dali::Actor *arg2 = 0 ;
34198   Dali::Vector2 *arg3 = 0 ;
34199
34200   arg1 = (Dali::RelayoutContainer *)jarg1;
34201   arg2 = (Dali::Actor *)jarg2;
34202   if (!arg2) {
34203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34204     return ;
34205   }
34206   arg3 = (Dali::Vector2 *)jarg3;
34207   if (!arg3) {
34208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34209     return ;
34210   }
34211   {
34212     try {
34213       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
34214     } catch (std::out_of_range& e) {
34215       {
34216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34217       };
34218     } catch (std::exception& e) {
34219       {
34220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34221       };
34222     } catch (...) {
34223       {
34224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34225       };
34226     }
34227   }
34228 }
34229
34230
34231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
34232   void * jresult ;
34233   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34234   Dali::CustomActor result;
34235
34236   arg1 = (Dali::CustomActorImpl *)jarg1;
34237   {
34238     try {
34239       result = ((Dali::CustomActorImpl const *)arg1)->Self();
34240     } catch (std::out_of_range& e) {
34241       {
34242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34243       };
34244     } catch (std::exception& e) {
34245       {
34246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34247       };
34248     } catch (...) {
34249       {
34250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34251       };
34252     }
34253   }
34254   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
34255   return jresult;
34256 }
34257
34258
34259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
34260   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34261   int arg2 ;
34262
34263   arg1 = (Dali::CustomActorImpl *)jarg1;
34264   arg2 = (int)jarg2;
34265   {
34266     try {
34267       (arg1)->OnStageConnection(arg2);
34268     } catch (std::out_of_range& e) {
34269       {
34270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34271       };
34272     } catch (std::exception& e) {
34273       {
34274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34275       };
34276     } catch (...) {
34277       {
34278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34279       };
34280     }
34281   }
34282 }
34283
34284
34285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
34286   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34287
34288   arg1 = (Dali::CustomActorImpl *)jarg1;
34289   {
34290     try {
34291       (arg1)->OnStageDisconnection();
34292     } catch (std::out_of_range& e) {
34293       {
34294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34295       };
34296     } catch (std::exception& e) {
34297       {
34298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34299       };
34300     } catch (...) {
34301       {
34302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34303       };
34304     }
34305   }
34306 }
34307
34308
34309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
34310   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34311   Dali::Actor *arg2 = 0 ;
34312
34313   arg1 = (Dali::CustomActorImpl *)jarg1;
34314   arg2 = (Dali::Actor *)jarg2;
34315   if (!arg2) {
34316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34317     return ;
34318   }
34319   {
34320     try {
34321       (arg1)->OnChildAdd(*arg2);
34322     } catch (std::out_of_range& e) {
34323       {
34324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34325       };
34326     } catch (std::exception& e) {
34327       {
34328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34329       };
34330     } catch (...) {
34331       {
34332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34333       };
34334     }
34335   }
34336 }
34337
34338
34339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
34340   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34341   Dali::Actor *arg2 = 0 ;
34342
34343   arg1 = (Dali::CustomActorImpl *)jarg1;
34344   arg2 = (Dali::Actor *)jarg2;
34345   if (!arg2) {
34346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34347     return ;
34348   }
34349   {
34350     try {
34351       (arg1)->OnChildRemove(*arg2);
34352     } catch (std::out_of_range& e) {
34353       {
34354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34355       };
34356     } catch (std::exception& e) {
34357       {
34358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34359       };
34360     } catch (...) {
34361       {
34362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34363       };
34364     }
34365   }
34366 }
34367
34368
34369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
34370   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34371   Dali::Property::Index arg2 ;
34372   Dali::Property::Value arg3 ;
34373   Dali::Property::Value *argp3 ;
34374
34375   arg1 = (Dali::CustomActorImpl *)jarg1;
34376   arg2 = (Dali::Property::Index)jarg2;
34377   argp3 = (Dali::Property::Value *)jarg3;
34378   if (!argp3) {
34379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
34380     return ;
34381   }
34382   arg3 = *argp3;
34383   {
34384     try {
34385       (arg1)->OnPropertySet(arg2,arg3);
34386     } catch (std::out_of_range& e) {
34387       {
34388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34389       };
34390     } catch (std::exception& e) {
34391       {
34392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34393       };
34394     } catch (...) {
34395       {
34396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34397       };
34398     }
34399   }
34400 }
34401
34402
34403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
34404   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34405   Dali::Vector3 *arg2 = 0 ;
34406
34407   arg1 = (Dali::CustomActorImpl *)jarg1;
34408   arg2 = (Dali::Vector3 *)jarg2;
34409   if (!arg2) {
34410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34411     return ;
34412   }
34413   {
34414     try {
34415       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
34416     } catch (std::out_of_range& e) {
34417       {
34418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34419       };
34420     } catch (std::exception& e) {
34421       {
34422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34423       };
34424     } catch (...) {
34425       {
34426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34427       };
34428     }
34429   }
34430 }
34431
34432
34433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
34434   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34435   Dali::Animation *arg2 = 0 ;
34436   Dali::Vector3 *arg3 = 0 ;
34437
34438   arg1 = (Dali::CustomActorImpl *)jarg1;
34439   arg2 = (Dali::Animation *)jarg2;
34440   if (!arg2) {
34441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
34442     return ;
34443   }
34444   arg3 = (Dali::Vector3 *)jarg3;
34445   if (!arg3) {
34446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34447     return ;
34448   }
34449   {
34450     try {
34451       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
34452     } catch (std::out_of_range& e) {
34453       {
34454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34455       };
34456     } catch (std::exception& e) {
34457       {
34458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34459       };
34460     } catch (...) {
34461       {
34462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34463       };
34464     }
34465   }
34466 }
34467
34468
34469 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
34470   unsigned int jresult ;
34471   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34472   Dali::TouchEvent *arg2 = 0 ;
34473   bool result;
34474
34475   arg1 = (Dali::CustomActorImpl *)jarg1;
34476   arg2 = (Dali::TouchEvent *)jarg2;
34477   if (!arg2) {
34478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
34479     return 0;
34480   }
34481   {
34482     try {
34483       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
34484     } catch (std::out_of_range& e) {
34485       {
34486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34487       };
34488     } catch (std::exception& e) {
34489       {
34490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34491       };
34492     } catch (...) {
34493       {
34494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34495       };
34496     }
34497   }
34498   jresult = result;
34499   return jresult;
34500 }
34501
34502
34503 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
34504   unsigned int jresult ;
34505   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34506   Dali::HoverEvent *arg2 = 0 ;
34507   bool result;
34508
34509   arg1 = (Dali::CustomActorImpl *)jarg1;
34510   arg2 = (Dali::HoverEvent *)jarg2;
34511   if (!arg2) {
34512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
34513     return 0;
34514   }
34515   {
34516     try {
34517       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
34518     } catch (std::out_of_range& e) {
34519       {
34520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34521       };
34522     } catch (std::exception& e) {
34523       {
34524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34525       };
34526     } catch (...) {
34527       {
34528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34529       };
34530     }
34531   }
34532   jresult = result;
34533   return jresult;
34534 }
34535
34536
34537 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
34538   unsigned int jresult ;
34539   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34540   Dali::KeyEvent *arg2 = 0 ;
34541   bool result;
34542
34543   arg1 = (Dali::CustomActorImpl *)jarg1;
34544   arg2 = (Dali::KeyEvent *)jarg2;
34545   if (!arg2) {
34546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
34547     return 0;
34548   }
34549   {
34550     try {
34551       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
34552     } catch (std::out_of_range& e) {
34553       {
34554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34555       };
34556     } catch (std::exception& e) {
34557       {
34558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34559       };
34560     } catch (...) {
34561       {
34562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34563       };
34564     }
34565   }
34566   jresult = result;
34567   return jresult;
34568 }
34569
34570
34571 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
34572   unsigned int jresult ;
34573   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34574   Dali::WheelEvent *arg2 = 0 ;
34575   bool result;
34576
34577   arg1 = (Dali::CustomActorImpl *)jarg1;
34578   arg2 = (Dali::WheelEvent *)jarg2;
34579   if (!arg2) {
34580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
34581     return 0;
34582   }
34583   {
34584     try {
34585       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
34586     } catch (std::out_of_range& e) {
34587       {
34588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34589       };
34590     } catch (std::exception& e) {
34591       {
34592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34593       };
34594     } catch (...) {
34595       {
34596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34597       };
34598     }
34599   }
34600   jresult = result;
34601   return jresult;
34602 }
34603
34604
34605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
34606   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34607   Dali::Vector2 *arg2 = 0 ;
34608   Dali::RelayoutContainer *arg3 = 0 ;
34609
34610   arg1 = (Dali::CustomActorImpl *)jarg1;
34611   arg2 = (Dali::Vector2 *)jarg2;
34612   if (!arg2) {
34613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34614     return ;
34615   }
34616   arg3 = (Dali::RelayoutContainer *)jarg3;
34617   if (!arg3) {
34618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
34619     return ;
34620   }
34621   {
34622     try {
34623       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
34624     } catch (std::out_of_range& e) {
34625       {
34626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34627       };
34628     } catch (std::exception& e) {
34629       {
34630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34631       };
34632     } catch (...) {
34633       {
34634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34635       };
34636     }
34637   }
34638 }
34639
34640
34641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
34642   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34643   Dali::ResizePolicy::Type arg2 ;
34644   Dali::Dimension::Type arg3 ;
34645
34646   arg1 = (Dali::CustomActorImpl *)jarg1;
34647   arg2 = (Dali::ResizePolicy::Type)jarg2;
34648   arg3 = (Dali::Dimension::Type)jarg3;
34649   {
34650     try {
34651       (arg1)->OnSetResizePolicy(arg2,arg3);
34652     } catch (std::out_of_range& e) {
34653       {
34654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34655       };
34656     } catch (std::exception& e) {
34657       {
34658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34659       };
34660     } catch (...) {
34661       {
34662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34663       };
34664     }
34665   }
34666 }
34667
34668
34669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
34670   void * jresult ;
34671   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34672   Dali::Vector3 result;
34673
34674   arg1 = (Dali::CustomActorImpl *)jarg1;
34675   {
34676     try {
34677       result = (arg1)->GetNaturalSize();
34678     } catch (std::out_of_range& e) {
34679       {
34680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34681       };
34682     } catch (std::exception& e) {
34683       {
34684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34685       };
34686     } catch (...) {
34687       {
34688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34689       };
34690     }
34691   }
34692   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34693   return jresult;
34694 }
34695
34696
34697 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
34698   float jresult ;
34699   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34700   Dali::Actor *arg2 = 0 ;
34701   Dali::Dimension::Type arg3 ;
34702   float result;
34703
34704   arg1 = (Dali::CustomActorImpl *)jarg1;
34705   arg2 = (Dali::Actor *)jarg2;
34706   if (!arg2) {
34707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34708     return 0;
34709   }
34710   arg3 = (Dali::Dimension::Type)jarg3;
34711   {
34712     try {
34713       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
34714     } catch (std::out_of_range& e) {
34715       {
34716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34717       };
34718     } catch (std::exception& e) {
34719       {
34720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34721       };
34722     } catch (...) {
34723       {
34724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34725       };
34726     }
34727   }
34728   jresult = result;
34729   return jresult;
34730 }
34731
34732
34733 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
34734   float jresult ;
34735   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34736   float arg2 ;
34737   float result;
34738
34739   arg1 = (Dali::CustomActorImpl *)jarg1;
34740   arg2 = (float)jarg2;
34741   {
34742     try {
34743       result = (float)(arg1)->GetHeightForWidth(arg2);
34744     } catch (std::out_of_range& e) {
34745       {
34746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34747       };
34748     } catch (std::exception& e) {
34749       {
34750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34751       };
34752     } catch (...) {
34753       {
34754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34755       };
34756     }
34757   }
34758   jresult = result;
34759   return jresult;
34760 }
34761
34762
34763 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
34764   float jresult ;
34765   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34766   float arg2 ;
34767   float result;
34768
34769   arg1 = (Dali::CustomActorImpl *)jarg1;
34770   arg2 = (float)jarg2;
34771   {
34772     try {
34773       result = (float)(arg1)->GetWidthForHeight(arg2);
34774     } catch (std::out_of_range& e) {
34775       {
34776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34777       };
34778     } catch (std::exception& e) {
34779       {
34780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34781       };
34782     } catch (...) {
34783       {
34784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34785       };
34786     }
34787   }
34788   jresult = result;
34789   return jresult;
34790 }
34791
34792
34793 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
34794   unsigned int jresult ;
34795   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34796   Dali::Dimension::Type arg2 ;
34797   bool result;
34798
34799   arg1 = (Dali::CustomActorImpl *)jarg1;
34800   arg2 = (Dali::Dimension::Type)jarg2;
34801   {
34802     try {
34803       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
34804     } catch (std::out_of_range& e) {
34805       {
34806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34807       };
34808     } catch (std::exception& e) {
34809       {
34810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34811       };
34812     } catch (...) {
34813       {
34814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34815       };
34816     }
34817   }
34818   jresult = result;
34819   return jresult;
34820 }
34821
34822
34823 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
34824   unsigned int jresult ;
34825   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34826   bool result;
34827
34828   arg1 = (Dali::CustomActorImpl *)jarg1;
34829   {
34830     try {
34831       result = (bool)(arg1)->RelayoutDependentOnChildren();
34832     } catch (std::out_of_range& e) {
34833       {
34834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34835       };
34836     } catch (std::exception& e) {
34837       {
34838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34839       };
34840     } catch (...) {
34841       {
34842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34843       };
34844     }
34845   }
34846   jresult = result;
34847   return jresult;
34848 }
34849
34850
34851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
34852   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34853   Dali::Dimension::Type arg2 ;
34854
34855   arg1 = (Dali::CustomActorImpl *)jarg1;
34856   arg2 = (Dali::Dimension::Type)jarg2;
34857   {
34858     try {
34859       (arg1)->OnCalculateRelayoutSize(arg2);
34860     } catch (std::out_of_range& e) {
34861       {
34862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34863       };
34864     } catch (std::exception& e) {
34865       {
34866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34867       };
34868     } catch (...) {
34869       {
34870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34871       };
34872     }
34873   }
34874 }
34875
34876
34877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
34878   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34879   float arg2 ;
34880   Dali::Dimension::Type arg3 ;
34881
34882   arg1 = (Dali::CustomActorImpl *)jarg1;
34883   arg2 = (float)jarg2;
34884   arg3 = (Dali::Dimension::Type)jarg3;
34885   {
34886     try {
34887       (arg1)->OnLayoutNegotiated(arg2,arg3);
34888     } catch (std::out_of_range& e) {
34889       {
34890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34891       };
34892     } catch (std::exception& e) {
34893       {
34894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34895       };
34896     } catch (...) {
34897       {
34898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34899       };
34900     }
34901   }
34902 }
34903
34904
34905 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
34906   unsigned int jresult ;
34907   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34908   bool result;
34909
34910   arg1 = (Dali::CustomActorImpl *)jarg1;
34911   {
34912     try {
34913       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
34914     } catch (std::out_of_range& e) {
34915       {
34916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34917       };
34918     } catch (std::exception& e) {
34919       {
34920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34921       };
34922     } catch (...) {
34923       {
34924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34925       };
34926     }
34927   }
34928   jresult = result;
34929   return jresult;
34930 }
34931
34932
34933 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
34934   unsigned int jresult ;
34935   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34936   bool result;
34937
34938   arg1 = (Dali::CustomActorImpl *)jarg1;
34939   {
34940     try {
34941       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
34942     } catch (std::out_of_range& e) {
34943       {
34944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34945       };
34946     } catch (std::exception& e) {
34947       {
34948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34949       };
34950     } catch (...) {
34951       {
34952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34953       };
34954     }
34955   }
34956   jresult = result;
34957   return jresult;
34958 }
34959
34960
34961 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
34962   unsigned int jresult ;
34963   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34964   bool result;
34965
34966   arg1 = (Dali::CustomActorImpl *)jarg1;
34967   {
34968     try {
34969       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
34970     } catch (std::out_of_range& e) {
34971       {
34972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34973       };
34974     } catch (std::exception& e) {
34975       {
34976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34977       };
34978     } catch (...) {
34979       {
34980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34981       };
34982     }
34983   }
34984   jresult = result;
34985   return jresult;
34986 }
34987
34988
34989 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
34990   unsigned int jresult ;
34991   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34992   bool result;
34993
34994   arg1 = (Dali::CustomActorImpl *)jarg1;
34995   {
34996     try {
34997       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
34998     } catch (std::out_of_range& e) {
34999       {
35000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35001       };
35002     } catch (std::exception& e) {
35003       {
35004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35005       };
35006     } catch (...) {
35007       {
35008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35009       };
35010     }
35011   }
35012   jresult = result;
35013   return jresult;
35014 }
35015
35016
35017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
35018   void * jresult ;
35019   Dali::CustomActor *result = 0 ;
35020
35021   {
35022     try {
35023       result = (Dali::CustomActor *)new Dali::CustomActor();
35024     } catch (std::out_of_range& e) {
35025       {
35026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35027       };
35028     } catch (std::exception& e) {
35029       {
35030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35031       };
35032     } catch (...) {
35033       {
35034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35035       };
35036     }
35037   }
35038   jresult = (void *)result;
35039   return jresult;
35040 }
35041
35042
35043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
35044   void * jresult ;
35045   Dali::BaseHandle arg1 ;
35046   Dali::BaseHandle *argp1 ;
35047   Dali::CustomActor result;
35048
35049   argp1 = (Dali::BaseHandle *)jarg1;
35050   if (!argp1) {
35051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35052     return 0;
35053   }
35054   arg1 = *argp1;
35055   {
35056     try {
35057       result = Dali::CustomActor::DownCast(arg1);
35058     } catch (std::out_of_range& e) {
35059       {
35060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35061       };
35062     } catch (std::exception& e) {
35063       {
35064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35065       };
35066     } catch (...) {
35067       {
35068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35069       };
35070     }
35071   }
35072   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
35073   return jresult;
35074 }
35075
35076
35077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
35078   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35079
35080   arg1 = (Dali::CustomActor *)jarg1;
35081   {
35082     try {
35083       delete arg1;
35084     } catch (std::out_of_range& e) {
35085       {
35086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35087       };
35088     } catch (std::exception& e) {
35089       {
35090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35091       };
35092     } catch (...) {
35093       {
35094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35095       };
35096     }
35097   }
35098 }
35099
35100
35101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
35102   void * jresult ;
35103   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35104   Dali::CustomActorImpl *result = 0 ;
35105
35106   arg1 = (Dali::CustomActor *)jarg1;
35107   {
35108     try {
35109       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
35110     } catch (std::out_of_range& e) {
35111       {
35112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35113       };
35114     } catch (std::exception& e) {
35115       {
35116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35117       };
35118     } catch (...) {
35119       {
35120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35121       };
35122     }
35123   }
35124   jresult = (void *)result;
35125   return jresult;
35126 }
35127
35128
35129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
35130   void * jresult ;
35131   Dali::CustomActorImpl *arg1 = 0 ;
35132   Dali::CustomActor *result = 0 ;
35133
35134   arg1 = (Dali::CustomActorImpl *)jarg1;
35135   if (!arg1) {
35136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
35137     return 0;
35138   }
35139   {
35140     try {
35141       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
35142     } catch (std::out_of_range& e) {
35143       {
35144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35145       };
35146     } catch (std::exception& e) {
35147       {
35148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35149       };
35150     } catch (...) {
35151       {
35152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35153       };
35154     }
35155   }
35156   jresult = (void *)result;
35157   return jresult;
35158 }
35159
35160
35161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
35162   void * jresult ;
35163   Dali::CustomActor *arg1 = 0 ;
35164   Dali::CustomActor *result = 0 ;
35165
35166   arg1 = (Dali::CustomActor *)jarg1;
35167   if (!arg1) {
35168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
35169     return 0;
35170   }
35171   {
35172     try {
35173       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
35174     } catch (std::out_of_range& e) {
35175       {
35176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35177       };
35178     } catch (std::exception& e) {
35179       {
35180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35181       };
35182     } catch (...) {
35183       {
35184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35185       };
35186     }
35187   }
35188   jresult = (void *)result;
35189   return jresult;
35190 }
35191
35192
35193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
35194   void * jresult ;
35195   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35196   Dali::CustomActor *arg2 = 0 ;
35197   Dali::CustomActor *result = 0 ;
35198
35199   arg1 = (Dali::CustomActor *)jarg1;
35200   arg2 = (Dali::CustomActor *)jarg2;
35201   if (!arg2) {
35202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
35203     return 0;
35204   }
35205   {
35206     try {
35207       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
35208     } catch (std::out_of_range& e) {
35209       {
35210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35211       };
35212     } catch (std::exception& e) {
35213       {
35214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35215       };
35216     } catch (...) {
35217       {
35218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35219       };
35220     }
35221   }
35222   jresult = (void *)result;
35223   return jresult;
35224 }
35225
35226
35227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
35228   int jresult ;
35229   int result;
35230
35231   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
35232   jresult = (int)result;
35233   return jresult;
35234 }
35235
35236
35237 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
35238   int jresult ;
35239   int result;
35240
35241   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
35242   jresult = (int)result;
35243   return jresult;
35244 }
35245
35246
35247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
35248   int jresult ;
35249   int result;
35250
35251   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
35252   jresult = (int)result;
35253   return jresult;
35254 }
35255
35256
35257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
35258   int jresult ;
35259   int result;
35260
35261   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
35262   jresult = (int)result;
35263   return jresult;
35264 }
35265
35266
35267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
35268   int jresult ;
35269   int result;
35270
35271   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
35272   jresult = (int)result;
35273   return jresult;
35274 }
35275
35276
35277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
35278   int jresult ;
35279   int result;
35280
35281   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
35282   jresult = (int)result;
35283   return jresult;
35284 }
35285
35286
35287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
35288   int jresult ;
35289   int result;
35290
35291   result = (int)Dali::PanGestureDetector::Property::PANNING;
35292   jresult = (int)result;
35293   return jresult;
35294 }
35295
35296
35297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
35298   void * jresult ;
35299   Dali::PanGestureDetector::Property *result = 0 ;
35300
35301   {
35302     try {
35303       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
35304     } catch (std::out_of_range& e) {
35305       {
35306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35307       };
35308     } catch (std::exception& e) {
35309       {
35310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35311       };
35312     } catch (...) {
35313       {
35314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35315       };
35316     }
35317   }
35318   jresult = (void *)result;
35319   return jresult;
35320 }
35321
35322
35323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
35324   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
35325
35326   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
35327   {
35328     try {
35329       delete arg1;
35330     } catch (std::out_of_range& e) {
35331       {
35332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35333       };
35334     } catch (std::exception& e) {
35335       {
35336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35337       };
35338     } catch (...) {
35339       {
35340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35341       };
35342     }
35343   }
35344 }
35345
35346
35347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
35348   void * jresult ;
35349   Dali::Radian *result = 0 ;
35350
35351   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
35352   jresult = (void *)result;
35353   return jresult;
35354 }
35355
35356
35357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
35358   void * jresult ;
35359   Dali::Radian *result = 0 ;
35360
35361   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
35362   jresult = (void *)result;
35363   return jresult;
35364 }
35365
35366
35367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
35368   void * jresult ;
35369   Dali::Radian *result = 0 ;
35370
35371   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
35372   jresult = (void *)result;
35373   return jresult;
35374 }
35375
35376
35377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
35378   void * jresult ;
35379   Dali::Radian *result = 0 ;
35380
35381   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
35382   jresult = (void *)result;
35383   return jresult;
35384 }
35385
35386
35387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
35388   void * jresult ;
35389   Dali::Radian *result = 0 ;
35390
35391   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
35392   jresult = (void *)result;
35393   return jresult;
35394 }
35395
35396
35397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
35398   void * jresult ;
35399   Dali::Radian *result = 0 ;
35400
35401   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
35402   jresult = (void *)result;
35403   return jresult;
35404 }
35405
35406
35407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
35408   void * jresult ;
35409   Dali::Radian *result = 0 ;
35410
35411   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
35412   jresult = (void *)result;
35413   return jresult;
35414 }
35415
35416
35417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
35418   void * jresult ;
35419   Dali::PanGestureDetector *result = 0 ;
35420
35421   {
35422     try {
35423       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
35424     } catch (std::out_of_range& e) {
35425       {
35426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35427       };
35428     } catch (std::exception& e) {
35429       {
35430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35431       };
35432     } catch (...) {
35433       {
35434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35435       };
35436     }
35437   }
35438   jresult = (void *)result;
35439   return jresult;
35440 }
35441
35442
35443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
35444   void * jresult ;
35445   Dali::PanGestureDetector result;
35446
35447   {
35448     try {
35449       result = Dali::PanGestureDetector::New();
35450     } catch (std::out_of_range& e) {
35451       {
35452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35453       };
35454     } catch (std::exception& e) {
35455       {
35456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35457       };
35458     } catch (...) {
35459       {
35460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35461       };
35462     }
35463   }
35464   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35465   return jresult;
35466 }
35467
35468
35469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
35470   void * jresult ;
35471   Dali::BaseHandle arg1 ;
35472   Dali::BaseHandle *argp1 ;
35473   Dali::PanGestureDetector result;
35474
35475   argp1 = (Dali::BaseHandle *)jarg1;
35476   if (!argp1) {
35477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35478     return 0;
35479   }
35480   arg1 = *argp1;
35481   {
35482     try {
35483       result = Dali::PanGestureDetector::DownCast(arg1);
35484     } catch (std::out_of_range& e) {
35485       {
35486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35487       };
35488     } catch (std::exception& e) {
35489       {
35490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35491       };
35492     } catch (...) {
35493       {
35494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35495       };
35496     }
35497   }
35498   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35499   return jresult;
35500 }
35501
35502
35503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
35504   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35505
35506   arg1 = (Dali::PanGestureDetector *)jarg1;
35507   {
35508     try {
35509       delete arg1;
35510     } catch (std::out_of_range& e) {
35511       {
35512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35513       };
35514     } catch (std::exception& e) {
35515       {
35516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35517       };
35518     } catch (...) {
35519       {
35520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35521       };
35522     }
35523   }
35524 }
35525
35526
35527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
35528   void * jresult ;
35529   Dali::PanGestureDetector *arg1 = 0 ;
35530   Dali::PanGestureDetector *result = 0 ;
35531
35532   arg1 = (Dali::PanGestureDetector *)jarg1;
35533   if (!arg1) {
35534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35535     return 0;
35536   }
35537   {
35538     try {
35539       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
35540     } catch (std::out_of_range& e) {
35541       {
35542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35543       };
35544     } catch (std::exception& e) {
35545       {
35546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35547       };
35548     } catch (...) {
35549       {
35550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35551       };
35552     }
35553   }
35554   jresult = (void *)result;
35555   return jresult;
35556 }
35557
35558
35559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
35560   void * jresult ;
35561   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35562   Dali::PanGestureDetector *arg2 = 0 ;
35563   Dali::PanGestureDetector *result = 0 ;
35564
35565   arg1 = (Dali::PanGestureDetector *)jarg1;
35566   arg2 = (Dali::PanGestureDetector *)jarg2;
35567   if (!arg2) {
35568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35569     return 0;
35570   }
35571   {
35572     try {
35573       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
35574     } catch (std::out_of_range& e) {
35575       {
35576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35577       };
35578     } catch (std::exception& e) {
35579       {
35580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35581       };
35582     } catch (...) {
35583       {
35584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35585       };
35586     }
35587   }
35588   jresult = (void *)result;
35589   return jresult;
35590 }
35591
35592
35593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
35594   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35595   unsigned int arg2 ;
35596
35597   arg1 = (Dali::PanGestureDetector *)jarg1;
35598   arg2 = (unsigned int)jarg2;
35599   {
35600     try {
35601       (arg1)->SetMinimumTouchesRequired(arg2);
35602     } catch (std::out_of_range& e) {
35603       {
35604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35605       };
35606     } catch (std::exception& e) {
35607       {
35608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35609       };
35610     } catch (...) {
35611       {
35612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35613       };
35614     }
35615   }
35616 }
35617
35618
35619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
35620   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35621   unsigned int arg2 ;
35622
35623   arg1 = (Dali::PanGestureDetector *)jarg1;
35624   arg2 = (unsigned int)jarg2;
35625   {
35626     try {
35627       (arg1)->SetMaximumTouchesRequired(arg2);
35628     } catch (std::out_of_range& e) {
35629       {
35630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35631       };
35632     } catch (std::exception& e) {
35633       {
35634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35635       };
35636     } catch (...) {
35637       {
35638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35639       };
35640     }
35641   }
35642 }
35643
35644
35645 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
35646   unsigned int jresult ;
35647   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35648   unsigned int result;
35649
35650   arg1 = (Dali::PanGestureDetector *)jarg1;
35651   {
35652     try {
35653       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
35654     } catch (std::out_of_range& e) {
35655       {
35656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35657       };
35658     } catch (std::exception& e) {
35659       {
35660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35661       };
35662     } catch (...) {
35663       {
35664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35665       };
35666     }
35667   }
35668   jresult = result;
35669   return jresult;
35670 }
35671
35672
35673 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
35674   unsigned int jresult ;
35675   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35676   unsigned int result;
35677
35678   arg1 = (Dali::PanGestureDetector *)jarg1;
35679   {
35680     try {
35681       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
35682     } catch (std::out_of_range& e) {
35683       {
35684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35685       };
35686     } catch (std::exception& e) {
35687       {
35688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35689       };
35690     } catch (...) {
35691       {
35692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35693       };
35694     }
35695   }
35696   jresult = result;
35697   return jresult;
35698 }
35699
35700
35701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35702   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35703   Dali::Radian arg2 ;
35704   Dali::Radian arg3 ;
35705   Dali::Radian *argp2 ;
35706   Dali::Radian *argp3 ;
35707
35708   arg1 = (Dali::PanGestureDetector *)jarg1;
35709   argp2 = (Dali::Radian *)jarg2;
35710   if (!argp2) {
35711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35712     return ;
35713   }
35714   arg2 = *argp2;
35715   argp3 = (Dali::Radian *)jarg3;
35716   if (!argp3) {
35717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35718     return ;
35719   }
35720   arg3 = *argp3;
35721   {
35722     try {
35723       (arg1)->AddAngle(arg2,arg3);
35724     } catch (std::out_of_range& e) {
35725       {
35726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35727       };
35728     } catch (std::exception& e) {
35729       {
35730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35731       };
35732     } catch (...) {
35733       {
35734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35735       };
35736     }
35737   }
35738 }
35739
35740
35741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
35742   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35743   Dali::Radian arg2 ;
35744   Dali::Radian *argp2 ;
35745
35746   arg1 = (Dali::PanGestureDetector *)jarg1;
35747   argp2 = (Dali::Radian *)jarg2;
35748   if (!argp2) {
35749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35750     return ;
35751   }
35752   arg2 = *argp2;
35753   {
35754     try {
35755       (arg1)->AddAngle(arg2);
35756     } catch (std::out_of_range& e) {
35757       {
35758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35759       };
35760     } catch (std::exception& e) {
35761       {
35762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35763       };
35764     } catch (...) {
35765       {
35766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35767       };
35768     }
35769   }
35770 }
35771
35772
35773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35774   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35775   Dali::Radian arg2 ;
35776   Dali::Radian arg3 ;
35777   Dali::Radian *argp2 ;
35778   Dali::Radian *argp3 ;
35779
35780   arg1 = (Dali::PanGestureDetector *)jarg1;
35781   argp2 = (Dali::Radian *)jarg2;
35782   if (!argp2) {
35783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35784     return ;
35785   }
35786   arg2 = *argp2;
35787   argp3 = (Dali::Radian *)jarg3;
35788   if (!argp3) {
35789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35790     return ;
35791   }
35792   arg3 = *argp3;
35793   {
35794     try {
35795       (arg1)->AddDirection(arg2,arg3);
35796     } catch (std::out_of_range& e) {
35797       {
35798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35799       };
35800     } catch (std::exception& e) {
35801       {
35802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35803       };
35804     } catch (...) {
35805       {
35806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35807       };
35808     }
35809   }
35810 }
35811
35812
35813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
35814   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35815   Dali::Radian arg2 ;
35816   Dali::Radian *argp2 ;
35817
35818   arg1 = (Dali::PanGestureDetector *)jarg1;
35819   argp2 = (Dali::Radian *)jarg2;
35820   if (!argp2) {
35821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35822     return ;
35823   }
35824   arg2 = *argp2;
35825   {
35826     try {
35827       (arg1)->AddDirection(arg2);
35828     } catch (std::out_of_range& e) {
35829       {
35830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35831       };
35832     } catch (std::exception& e) {
35833       {
35834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35835       };
35836     } catch (...) {
35837       {
35838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35839       };
35840     }
35841   }
35842 }
35843
35844
35845 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
35846   unsigned long jresult ;
35847   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35848   size_t result;
35849
35850   arg1 = (Dali::PanGestureDetector *)jarg1;
35851   {
35852     try {
35853       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
35854     } catch (std::out_of_range& e) {
35855       {
35856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35857       };
35858     } catch (std::exception& e) {
35859       {
35860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35861       };
35862     } catch (...) {
35863       {
35864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35865       };
35866     }
35867   }
35868   jresult = (unsigned long)result;
35869   return jresult;
35870 }
35871
35872
35873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
35874   void * jresult ;
35875   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35876   size_t arg2 ;
35877   Dali::PanGestureDetector::AngleThresholdPair result;
35878
35879   arg1 = (Dali::PanGestureDetector *)jarg1;
35880   arg2 = (size_t)jarg2;
35881   {
35882     try {
35883       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
35884     } catch (std::out_of_range& e) {
35885       {
35886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35887       };
35888     } catch (std::exception& e) {
35889       {
35890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35891       };
35892     } catch (...) {
35893       {
35894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35895       };
35896     }
35897   }
35898   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
35899   return jresult;
35900 }
35901
35902
35903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
35904   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35905
35906   arg1 = (Dali::PanGestureDetector *)jarg1;
35907   {
35908     try {
35909       (arg1)->ClearAngles();
35910     } catch (std::out_of_range& e) {
35911       {
35912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35913       };
35914     } catch (std::exception& e) {
35915       {
35916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35917       };
35918     } catch (...) {
35919       {
35920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35921       };
35922     }
35923   }
35924 }
35925
35926
35927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
35928   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35929   Dali::Radian arg2 ;
35930   Dali::Radian *argp2 ;
35931
35932   arg1 = (Dali::PanGestureDetector *)jarg1;
35933   argp2 = (Dali::Radian *)jarg2;
35934   if (!argp2) {
35935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35936     return ;
35937   }
35938   arg2 = *argp2;
35939   {
35940     try {
35941       (arg1)->RemoveAngle(arg2);
35942     } catch (std::out_of_range& e) {
35943       {
35944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35945       };
35946     } catch (std::exception& e) {
35947       {
35948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35949       };
35950     } catch (...) {
35951       {
35952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35953       };
35954     }
35955   }
35956 }
35957
35958
35959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
35960   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35961   Dali::Radian arg2 ;
35962   Dali::Radian *argp2 ;
35963
35964   arg1 = (Dali::PanGestureDetector *)jarg1;
35965   argp2 = (Dali::Radian *)jarg2;
35966   if (!argp2) {
35967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35968     return ;
35969   }
35970   arg2 = *argp2;
35971   {
35972     try {
35973       (arg1)->RemoveDirection(arg2);
35974     } catch (std::out_of_range& e) {
35975       {
35976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35977       };
35978     } catch (std::exception& e) {
35979       {
35980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35981       };
35982     } catch (...) {
35983       {
35984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35985       };
35986     }
35987   }
35988 }
35989
35990
35991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
35992   void * jresult ;
35993   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35994   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
35995
35996   arg1 = (Dali::PanGestureDetector *)jarg1;
35997   {
35998     try {
35999       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
36000     } catch (std::out_of_range& e) {
36001       {
36002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36003       };
36004     } catch (std::exception& e) {
36005       {
36006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36007       };
36008     } catch (...) {
36009       {
36010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36011       };
36012     }
36013   }
36014   jresult = (void *)result;
36015   return jresult;
36016 }
36017
36018
36019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
36020   Dali::PanGesture *arg1 = 0 ;
36021
36022   arg1 = (Dali::PanGesture *)jarg1;
36023   if (!arg1) {
36024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36025     return ;
36026   }
36027   {
36028     try {
36029       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
36030     } catch (std::out_of_range& e) {
36031       {
36032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36033       };
36034     } catch (std::exception& e) {
36035       {
36036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36037       };
36038     } catch (...) {
36039       {
36040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36041       };
36042     }
36043   }
36044 }
36045
36046
36047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
36048   void * jresult ;
36049   Dali::PanGesture *result = 0 ;
36050
36051   {
36052     try {
36053       result = (Dali::PanGesture *)new Dali::PanGesture();
36054     } catch (std::out_of_range& e) {
36055       {
36056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36057       };
36058     } catch (std::exception& e) {
36059       {
36060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36061       };
36062     } catch (...) {
36063       {
36064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36065       };
36066     }
36067   }
36068   jresult = (void *)result;
36069   return jresult;
36070 }
36071
36072
36073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
36074   void * jresult ;
36075   Dali::Gesture::State arg1 ;
36076   Dali::PanGesture *result = 0 ;
36077
36078   arg1 = (Dali::Gesture::State)jarg1;
36079   {
36080     try {
36081       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
36082     } catch (std::out_of_range& e) {
36083       {
36084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36085       };
36086     } catch (std::exception& e) {
36087       {
36088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36089       };
36090     } catch (...) {
36091       {
36092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36093       };
36094     }
36095   }
36096   jresult = (void *)result;
36097   return jresult;
36098 }
36099
36100
36101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
36102   void * jresult ;
36103   Dali::PanGesture *arg1 = 0 ;
36104   Dali::PanGesture *result = 0 ;
36105
36106   arg1 = (Dali::PanGesture *)jarg1;
36107   if (!arg1) {
36108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36109     return 0;
36110   }
36111   {
36112     try {
36113       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
36114     } catch (std::out_of_range& e) {
36115       {
36116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36117       };
36118     } catch (std::exception& e) {
36119       {
36120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36121       };
36122     } catch (...) {
36123       {
36124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36125       };
36126     }
36127   }
36128   jresult = (void *)result;
36129   return jresult;
36130 }
36131
36132
36133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
36134   void * jresult ;
36135   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36136   Dali::PanGesture *arg2 = 0 ;
36137   Dali::PanGesture *result = 0 ;
36138
36139   arg1 = (Dali::PanGesture *)jarg1;
36140   arg2 = (Dali::PanGesture *)jarg2;
36141   if (!arg2) {
36142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36143     return 0;
36144   }
36145   {
36146     try {
36147       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
36148     } catch (std::out_of_range& e) {
36149       {
36150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36151       };
36152     } catch (std::exception& e) {
36153       {
36154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36155       };
36156     } catch (...) {
36157       {
36158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36159       };
36160     }
36161   }
36162   jresult = (void *)result;
36163   return jresult;
36164 }
36165
36166
36167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
36168   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36169
36170   arg1 = (Dali::PanGesture *)jarg1;
36171   {
36172     try {
36173       delete arg1;
36174     } catch (std::out_of_range& e) {
36175       {
36176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36177       };
36178     } catch (std::exception& e) {
36179       {
36180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36181       };
36182     } catch (...) {
36183       {
36184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36185       };
36186     }
36187   }
36188 }
36189
36190
36191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
36192   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36193   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36194
36195   arg1 = (Dali::PanGesture *)jarg1;
36196   arg2 = (Dali::Vector2 *)jarg2;
36197   if (arg1) (arg1)->velocity = *arg2;
36198 }
36199
36200
36201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
36202   void * jresult ;
36203   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36204   Dali::Vector2 *result = 0 ;
36205
36206   arg1 = (Dali::PanGesture *)jarg1;
36207   result = (Dali::Vector2 *)& ((arg1)->velocity);
36208   jresult = (void *)result;
36209   return jresult;
36210 }
36211
36212
36213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
36214   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36215   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36216
36217   arg1 = (Dali::PanGesture *)jarg1;
36218   arg2 = (Dali::Vector2 *)jarg2;
36219   if (arg1) (arg1)->displacement = *arg2;
36220 }
36221
36222
36223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
36224   void * jresult ;
36225   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36226   Dali::Vector2 *result = 0 ;
36227
36228   arg1 = (Dali::PanGesture *)jarg1;
36229   result = (Dali::Vector2 *)& ((arg1)->displacement);
36230   jresult = (void *)result;
36231   return jresult;
36232 }
36233
36234
36235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
36236   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36237   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36238
36239   arg1 = (Dali::PanGesture *)jarg1;
36240   arg2 = (Dali::Vector2 *)jarg2;
36241   if (arg1) (arg1)->position = *arg2;
36242 }
36243
36244
36245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
36246   void * jresult ;
36247   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36248   Dali::Vector2 *result = 0 ;
36249
36250   arg1 = (Dali::PanGesture *)jarg1;
36251   result = (Dali::Vector2 *)& ((arg1)->position);
36252   jresult = (void *)result;
36253   return jresult;
36254 }
36255
36256
36257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
36258   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36259   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36260
36261   arg1 = (Dali::PanGesture *)jarg1;
36262   arg2 = (Dali::Vector2 *)jarg2;
36263   if (arg1) (arg1)->screenVelocity = *arg2;
36264 }
36265
36266
36267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
36268   void * jresult ;
36269   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36270   Dali::Vector2 *result = 0 ;
36271
36272   arg1 = (Dali::PanGesture *)jarg1;
36273   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
36274   jresult = (void *)result;
36275   return jresult;
36276 }
36277
36278
36279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
36280   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36281   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36282
36283   arg1 = (Dali::PanGesture *)jarg1;
36284   arg2 = (Dali::Vector2 *)jarg2;
36285   if (arg1) (arg1)->screenDisplacement = *arg2;
36286 }
36287
36288
36289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
36290   void * jresult ;
36291   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36292   Dali::Vector2 *result = 0 ;
36293
36294   arg1 = (Dali::PanGesture *)jarg1;
36295   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
36296   jresult = (void *)result;
36297   return jresult;
36298 }
36299
36300
36301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
36302   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36303   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36304
36305   arg1 = (Dali::PanGesture *)jarg1;
36306   arg2 = (Dali::Vector2 *)jarg2;
36307   if (arg1) (arg1)->screenPosition = *arg2;
36308 }
36309
36310
36311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
36312   void * jresult ;
36313   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36314   Dali::Vector2 *result = 0 ;
36315
36316   arg1 = (Dali::PanGesture *)jarg1;
36317   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
36318   jresult = (void *)result;
36319   return jresult;
36320 }
36321
36322
36323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
36324   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36325   unsigned int arg2 ;
36326
36327   arg1 = (Dali::PanGesture *)jarg1;
36328   arg2 = (unsigned int)jarg2;
36329   if (arg1) (arg1)->numberOfTouches = arg2;
36330 }
36331
36332
36333 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
36334   unsigned int jresult ;
36335   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36336   unsigned int result;
36337
36338   arg1 = (Dali::PanGesture *)jarg1;
36339   result = (unsigned int) ((arg1)->numberOfTouches);
36340   jresult = result;
36341   return jresult;
36342 }
36343
36344
36345 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
36346   float jresult ;
36347   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36348   float result;
36349
36350   arg1 = (Dali::PanGesture *)jarg1;
36351   {
36352     try {
36353       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
36354     } catch (std::out_of_range& e) {
36355       {
36356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36357       };
36358     } catch (std::exception& e) {
36359       {
36360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36361       };
36362     } catch (...) {
36363       {
36364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36365       };
36366     }
36367   }
36368   jresult = result;
36369   return jresult;
36370 }
36371
36372
36373 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
36374   float jresult ;
36375   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36376   float result;
36377
36378   arg1 = (Dali::PanGesture *)jarg1;
36379   {
36380     try {
36381       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
36382     } catch (std::out_of_range& e) {
36383       {
36384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36385       };
36386     } catch (std::exception& e) {
36387       {
36388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36389       };
36390     } catch (...) {
36391       {
36392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36393       };
36394     }
36395   }
36396   jresult = result;
36397   return jresult;
36398 }
36399
36400
36401 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
36402   float jresult ;
36403   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36404   float result;
36405
36406   arg1 = (Dali::PanGesture *)jarg1;
36407   {
36408     try {
36409       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
36410     } catch (std::out_of_range& e) {
36411       {
36412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36413       };
36414     } catch (std::exception& e) {
36415       {
36416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36417       };
36418     } catch (...) {
36419       {
36420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36421       };
36422     }
36423   }
36424   jresult = result;
36425   return jresult;
36426 }
36427
36428
36429 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
36430   float jresult ;
36431   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36432   float result;
36433
36434   arg1 = (Dali::PanGesture *)jarg1;
36435   {
36436     try {
36437       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
36438     } catch (std::out_of_range& e) {
36439       {
36440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36441       };
36442     } catch (std::exception& e) {
36443       {
36444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36445       };
36446     } catch (...) {
36447       {
36448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36449       };
36450     }
36451   }
36452   jresult = result;
36453   return jresult;
36454 }
36455
36456
36457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
36458   void * jresult ;
36459   Dali::PinchGestureDetector *result = 0 ;
36460
36461   {
36462     try {
36463       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
36464     } catch (std::out_of_range& e) {
36465       {
36466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36467       };
36468     } catch (std::exception& e) {
36469       {
36470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36471       };
36472     } catch (...) {
36473       {
36474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36475       };
36476     }
36477   }
36478   jresult = (void *)result;
36479   return jresult;
36480 }
36481
36482
36483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
36484   void * jresult ;
36485   Dali::PinchGestureDetector result;
36486
36487   {
36488     try {
36489       result = Dali::PinchGestureDetector::New();
36490     } catch (std::out_of_range& e) {
36491       {
36492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36493       };
36494     } catch (std::exception& e) {
36495       {
36496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36497       };
36498     } catch (...) {
36499       {
36500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36501       };
36502     }
36503   }
36504   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36505   return jresult;
36506 }
36507
36508
36509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
36510   void * jresult ;
36511   Dali::BaseHandle arg1 ;
36512   Dali::BaseHandle *argp1 ;
36513   Dali::PinchGestureDetector result;
36514
36515   argp1 = (Dali::BaseHandle *)jarg1;
36516   if (!argp1) {
36517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36518     return 0;
36519   }
36520   arg1 = *argp1;
36521   {
36522     try {
36523       result = Dali::PinchGestureDetector::DownCast(arg1);
36524     } catch (std::out_of_range& e) {
36525       {
36526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36527       };
36528     } catch (std::exception& e) {
36529       {
36530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36531       };
36532     } catch (...) {
36533       {
36534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36535       };
36536     }
36537   }
36538   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36539   return jresult;
36540 }
36541
36542
36543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
36544   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36545
36546   arg1 = (Dali::PinchGestureDetector *)jarg1;
36547   {
36548     try {
36549       delete arg1;
36550     } catch (std::out_of_range& e) {
36551       {
36552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36553       };
36554     } catch (std::exception& e) {
36555       {
36556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36557       };
36558     } catch (...) {
36559       {
36560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36561       };
36562     }
36563   }
36564 }
36565
36566
36567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
36568   void * jresult ;
36569   Dali::PinchGestureDetector *arg1 = 0 ;
36570   Dali::PinchGestureDetector *result = 0 ;
36571
36572   arg1 = (Dali::PinchGestureDetector *)jarg1;
36573   if (!arg1) {
36574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36575     return 0;
36576   }
36577   {
36578     try {
36579       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
36580     } catch (std::out_of_range& e) {
36581       {
36582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36583       };
36584     } catch (std::exception& e) {
36585       {
36586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36587       };
36588     } catch (...) {
36589       {
36590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36591       };
36592     }
36593   }
36594   jresult = (void *)result;
36595   return jresult;
36596 }
36597
36598
36599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
36600   void * jresult ;
36601   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36602   Dali::PinchGestureDetector *arg2 = 0 ;
36603   Dali::PinchGestureDetector *result = 0 ;
36604
36605   arg1 = (Dali::PinchGestureDetector *)jarg1;
36606   arg2 = (Dali::PinchGestureDetector *)jarg2;
36607   if (!arg2) {
36608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36609     return 0;
36610   }
36611   {
36612     try {
36613       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
36614     } catch (std::out_of_range& e) {
36615       {
36616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36617       };
36618     } catch (std::exception& e) {
36619       {
36620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36621       };
36622     } catch (...) {
36623       {
36624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36625       };
36626     }
36627   }
36628   jresult = (void *)result;
36629   return jresult;
36630 }
36631
36632
36633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
36634   void * jresult ;
36635   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36636   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
36637
36638   arg1 = (Dali::PinchGestureDetector *)jarg1;
36639   {
36640     try {
36641       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
36642     } catch (std::out_of_range& e) {
36643       {
36644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36645       };
36646     } catch (std::exception& e) {
36647       {
36648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36649       };
36650     } catch (...) {
36651       {
36652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36653       };
36654     }
36655   }
36656   jresult = (void *)result;
36657   return jresult;
36658 }
36659
36660
36661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
36662   void * jresult ;
36663   Dali::Gesture::State arg1 ;
36664   Dali::PinchGesture *result = 0 ;
36665
36666   arg1 = (Dali::Gesture::State)jarg1;
36667   {
36668     try {
36669       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
36670     } catch (std::out_of_range& e) {
36671       {
36672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36673       };
36674     } catch (std::exception& e) {
36675       {
36676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36677       };
36678     } catch (...) {
36679       {
36680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36681       };
36682     }
36683   }
36684   jresult = (void *)result;
36685   return jresult;
36686 }
36687
36688
36689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
36690   void * jresult ;
36691   Dali::PinchGesture *arg1 = 0 ;
36692   Dali::PinchGesture *result = 0 ;
36693
36694   arg1 = (Dali::PinchGesture *)jarg1;
36695   if (!arg1) {
36696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36697     return 0;
36698   }
36699   {
36700     try {
36701       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
36702     } catch (std::out_of_range& e) {
36703       {
36704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36705       };
36706     } catch (std::exception& e) {
36707       {
36708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36709       };
36710     } catch (...) {
36711       {
36712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36713       };
36714     }
36715   }
36716   jresult = (void *)result;
36717   return jresult;
36718 }
36719
36720
36721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
36722   void * jresult ;
36723   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36724   Dali::PinchGesture *arg2 = 0 ;
36725   Dali::PinchGesture *result = 0 ;
36726
36727   arg1 = (Dali::PinchGesture *)jarg1;
36728   arg2 = (Dali::PinchGesture *)jarg2;
36729   if (!arg2) {
36730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36731     return 0;
36732   }
36733   {
36734     try {
36735       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
36736     } catch (std::out_of_range& e) {
36737       {
36738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36739       };
36740     } catch (std::exception& e) {
36741       {
36742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36743       };
36744     } catch (...) {
36745       {
36746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36747       };
36748     }
36749   }
36750   jresult = (void *)result;
36751   return jresult;
36752 }
36753
36754
36755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
36756   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36757
36758   arg1 = (Dali::PinchGesture *)jarg1;
36759   {
36760     try {
36761       delete arg1;
36762     } catch (std::out_of_range& e) {
36763       {
36764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36765       };
36766     } catch (std::exception& e) {
36767       {
36768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36769       };
36770     } catch (...) {
36771       {
36772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36773       };
36774     }
36775   }
36776 }
36777
36778
36779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
36780   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36781   float arg2 ;
36782
36783   arg1 = (Dali::PinchGesture *)jarg1;
36784   arg2 = (float)jarg2;
36785   if (arg1) (arg1)->scale = arg2;
36786 }
36787
36788
36789 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
36790   float jresult ;
36791   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36792   float result;
36793
36794   arg1 = (Dali::PinchGesture *)jarg1;
36795   result = (float) ((arg1)->scale);
36796   jresult = result;
36797   return jresult;
36798 }
36799
36800
36801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
36802   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36803   float arg2 ;
36804
36805   arg1 = (Dali::PinchGesture *)jarg1;
36806   arg2 = (float)jarg2;
36807   if (arg1) (arg1)->speed = arg2;
36808 }
36809
36810
36811 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
36812   float jresult ;
36813   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36814   float result;
36815
36816   arg1 = (Dali::PinchGesture *)jarg1;
36817   result = (float) ((arg1)->speed);
36818   jresult = result;
36819   return jresult;
36820 }
36821
36822
36823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
36824   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36825   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36826
36827   arg1 = (Dali::PinchGesture *)jarg1;
36828   arg2 = (Dali::Vector2 *)jarg2;
36829   if (arg1) (arg1)->screenCenterPoint = *arg2;
36830 }
36831
36832
36833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
36834   void * jresult ;
36835   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36836   Dali::Vector2 *result = 0 ;
36837
36838   arg1 = (Dali::PinchGesture *)jarg1;
36839   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
36840   jresult = (void *)result;
36841   return jresult;
36842 }
36843
36844
36845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
36846   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36847   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36848
36849   arg1 = (Dali::PinchGesture *)jarg1;
36850   arg2 = (Dali::Vector2 *)jarg2;
36851   if (arg1) (arg1)->localCenterPoint = *arg2;
36852 }
36853
36854
36855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
36856   void * jresult ;
36857   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36858   Dali::Vector2 *result = 0 ;
36859
36860   arg1 = (Dali::PinchGesture *)jarg1;
36861   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
36862   jresult = (void *)result;
36863   return jresult;
36864 }
36865
36866
36867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
36868   void * jresult ;
36869   Dali::TapGestureDetector *result = 0 ;
36870
36871   {
36872     try {
36873       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
36874     } catch (std::out_of_range& e) {
36875       {
36876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36877       };
36878     } catch (std::exception& e) {
36879       {
36880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36881       };
36882     } catch (...) {
36883       {
36884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36885       };
36886     }
36887   }
36888   jresult = (void *)result;
36889   return jresult;
36890 }
36891
36892
36893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
36894   void * jresult ;
36895   Dali::TapGestureDetector result;
36896
36897   {
36898     try {
36899       result = Dali::TapGestureDetector::New();
36900     } catch (std::out_of_range& e) {
36901       {
36902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36903       };
36904     } catch (std::exception& e) {
36905       {
36906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36907       };
36908     } catch (...) {
36909       {
36910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36911       };
36912     }
36913   }
36914   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36915   return jresult;
36916 }
36917
36918
36919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
36920   void * jresult ;
36921   unsigned int arg1 ;
36922   Dali::TapGestureDetector result;
36923
36924   arg1 = (unsigned int)jarg1;
36925   {
36926     try {
36927       result = Dali::TapGestureDetector::New(arg1);
36928     } catch (std::out_of_range& e) {
36929       {
36930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36931       };
36932     } catch (std::exception& e) {
36933       {
36934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36935       };
36936     } catch (...) {
36937       {
36938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36939       };
36940     }
36941   }
36942   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36943   return jresult;
36944 }
36945
36946
36947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
36948   void * jresult ;
36949   Dali::BaseHandle arg1 ;
36950   Dali::BaseHandle *argp1 ;
36951   Dali::TapGestureDetector result;
36952
36953   argp1 = (Dali::BaseHandle *)jarg1;
36954   if (!argp1) {
36955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36956     return 0;
36957   }
36958   arg1 = *argp1;
36959   {
36960     try {
36961       result = Dali::TapGestureDetector::DownCast(arg1);
36962     } catch (std::out_of_range& e) {
36963       {
36964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36965       };
36966     } catch (std::exception& e) {
36967       {
36968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36969       };
36970     } catch (...) {
36971       {
36972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36973       };
36974     }
36975   }
36976   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36977   return jresult;
36978 }
36979
36980
36981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
36982   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36983
36984   arg1 = (Dali::TapGestureDetector *)jarg1;
36985   {
36986     try {
36987       delete arg1;
36988     } catch (std::out_of_range& e) {
36989       {
36990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36991       };
36992     } catch (std::exception& e) {
36993       {
36994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36995       };
36996     } catch (...) {
36997       {
36998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36999       };
37000     }
37001   }
37002 }
37003
37004
37005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
37006   void * jresult ;
37007   Dali::TapGestureDetector *arg1 = 0 ;
37008   Dali::TapGestureDetector *result = 0 ;
37009
37010   arg1 = (Dali::TapGestureDetector *)jarg1;
37011   if (!arg1) {
37012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
37013     return 0;
37014   }
37015   {
37016     try {
37017       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
37018     } catch (std::out_of_range& e) {
37019       {
37020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37021       };
37022     } catch (std::exception& e) {
37023       {
37024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37025       };
37026     } catch (...) {
37027       {
37028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37029       };
37030     }
37031   }
37032   jresult = (void *)result;
37033   return jresult;
37034 }
37035
37036
37037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
37038   void * jresult ;
37039   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37040   Dali::TapGestureDetector *arg2 = 0 ;
37041   Dali::TapGestureDetector *result = 0 ;
37042
37043   arg1 = (Dali::TapGestureDetector *)jarg1;
37044   arg2 = (Dali::TapGestureDetector *)jarg2;
37045   if (!arg2) {
37046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
37047     return 0;
37048   }
37049   {
37050     try {
37051       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
37052     } catch (std::out_of_range& e) {
37053       {
37054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37055       };
37056     } catch (std::exception& e) {
37057       {
37058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37059       };
37060     } catch (...) {
37061       {
37062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37063       };
37064     }
37065   }
37066   jresult = (void *)result;
37067   return jresult;
37068 }
37069
37070
37071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
37072   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37073   unsigned int arg2 ;
37074
37075   arg1 = (Dali::TapGestureDetector *)jarg1;
37076   arg2 = (unsigned int)jarg2;
37077   {
37078     try {
37079       (arg1)->SetMinimumTapsRequired(arg2);
37080     } catch (std::out_of_range& e) {
37081       {
37082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37083       };
37084     } catch (std::exception& e) {
37085       {
37086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37087       };
37088     } catch (...) {
37089       {
37090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37091       };
37092     }
37093   }
37094 }
37095
37096
37097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
37098   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37099   unsigned int arg2 ;
37100
37101   arg1 = (Dali::TapGestureDetector *)jarg1;
37102   arg2 = (unsigned int)jarg2;
37103   {
37104     try {
37105       (arg1)->SetMaximumTapsRequired(arg2);
37106     } catch (std::out_of_range& e) {
37107       {
37108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37109       };
37110     } catch (std::exception& e) {
37111       {
37112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37113       };
37114     } catch (...) {
37115       {
37116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37117       };
37118     }
37119   }
37120 }
37121
37122
37123 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
37124   unsigned int jresult ;
37125   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37126   unsigned int result;
37127
37128   arg1 = (Dali::TapGestureDetector *)jarg1;
37129   {
37130     try {
37131       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
37132     } catch (std::out_of_range& e) {
37133       {
37134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37135       };
37136     } catch (std::exception& e) {
37137       {
37138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37139       };
37140     } catch (...) {
37141       {
37142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37143       };
37144     }
37145   }
37146   jresult = result;
37147   return jresult;
37148 }
37149
37150
37151 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
37152   unsigned int jresult ;
37153   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37154   unsigned int result;
37155
37156   arg1 = (Dali::TapGestureDetector *)jarg1;
37157   {
37158     try {
37159       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
37160     } catch (std::out_of_range& e) {
37161       {
37162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37163       };
37164     } catch (std::exception& e) {
37165       {
37166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37167       };
37168     } catch (...) {
37169       {
37170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37171       };
37172     }
37173   }
37174   jresult = result;
37175   return jresult;
37176 }
37177
37178
37179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
37180   void * jresult ;
37181   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37182   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
37183
37184   arg1 = (Dali::TapGestureDetector *)jarg1;
37185   {
37186     try {
37187       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
37188     } catch (std::out_of_range& e) {
37189       {
37190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37191       };
37192     } catch (std::exception& e) {
37193       {
37194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37195       };
37196     } catch (...) {
37197       {
37198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37199       };
37200     }
37201   }
37202   jresult = (void *)result;
37203   return jresult;
37204 }
37205
37206
37207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
37208   void * jresult ;
37209   Dali::TapGesture *result = 0 ;
37210
37211   {
37212     try {
37213       result = (Dali::TapGesture *)new Dali::TapGesture();
37214     } catch (std::out_of_range& e) {
37215       {
37216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37217       };
37218     } catch (std::exception& e) {
37219       {
37220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37221       };
37222     } catch (...) {
37223       {
37224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37225       };
37226     }
37227   }
37228   jresult = (void *)result;
37229   return jresult;
37230 }
37231
37232
37233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
37234   void * jresult ;
37235   Dali::TapGesture *arg1 = 0 ;
37236   Dali::TapGesture *result = 0 ;
37237
37238   arg1 = (Dali::TapGesture *)jarg1;
37239   if (!arg1) {
37240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37241     return 0;
37242   }
37243   {
37244     try {
37245       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
37246     } catch (std::out_of_range& e) {
37247       {
37248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37249       };
37250     } catch (std::exception& e) {
37251       {
37252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37253       };
37254     } catch (...) {
37255       {
37256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37257       };
37258     }
37259   }
37260   jresult = (void *)result;
37261   return jresult;
37262 }
37263
37264
37265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
37266   void * jresult ;
37267   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37268   Dali::TapGesture *arg2 = 0 ;
37269   Dali::TapGesture *result = 0 ;
37270
37271   arg1 = (Dali::TapGesture *)jarg1;
37272   arg2 = (Dali::TapGesture *)jarg2;
37273   if (!arg2) {
37274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37275     return 0;
37276   }
37277   {
37278     try {
37279       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
37280     } catch (std::out_of_range& e) {
37281       {
37282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37283       };
37284     } catch (std::exception& e) {
37285       {
37286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37287       };
37288     } catch (...) {
37289       {
37290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37291       };
37292     }
37293   }
37294   jresult = (void *)result;
37295   return jresult;
37296 }
37297
37298
37299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
37300   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37301
37302   arg1 = (Dali::TapGesture *)jarg1;
37303   {
37304     try {
37305       delete arg1;
37306     } catch (std::out_of_range& e) {
37307       {
37308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37309       };
37310     } catch (std::exception& e) {
37311       {
37312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37313       };
37314     } catch (...) {
37315       {
37316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37317       };
37318     }
37319   }
37320 }
37321
37322
37323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
37324   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37325   unsigned int arg2 ;
37326
37327   arg1 = (Dali::TapGesture *)jarg1;
37328   arg2 = (unsigned int)jarg2;
37329   if (arg1) (arg1)->numberOfTaps = arg2;
37330 }
37331
37332
37333 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
37334   unsigned int jresult ;
37335   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37336   unsigned int result;
37337
37338   arg1 = (Dali::TapGesture *)jarg1;
37339   result = (unsigned int) ((arg1)->numberOfTaps);
37340   jresult = result;
37341   return jresult;
37342 }
37343
37344
37345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
37346   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37347   unsigned int arg2 ;
37348
37349   arg1 = (Dali::TapGesture *)jarg1;
37350   arg2 = (unsigned int)jarg2;
37351   if (arg1) (arg1)->numberOfTouches = arg2;
37352 }
37353
37354
37355 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
37356   unsigned int jresult ;
37357   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37358   unsigned int result;
37359
37360   arg1 = (Dali::TapGesture *)jarg1;
37361   result = (unsigned int) ((arg1)->numberOfTouches);
37362   jresult = result;
37363   return jresult;
37364 }
37365
37366
37367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
37368   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37369   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37370
37371   arg1 = (Dali::TapGesture *)jarg1;
37372   arg2 = (Dali::Vector2 *)jarg2;
37373   if (arg1) (arg1)->screenPoint = *arg2;
37374 }
37375
37376
37377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
37378   void * jresult ;
37379   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37380   Dali::Vector2 *result = 0 ;
37381
37382   arg1 = (Dali::TapGesture *)jarg1;
37383   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
37384   jresult = (void *)result;
37385   return jresult;
37386 }
37387
37388
37389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
37390   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37391   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37392
37393   arg1 = (Dali::TapGesture *)jarg1;
37394   arg2 = (Dali::Vector2 *)jarg2;
37395   if (arg1) (arg1)->localPoint = *arg2;
37396 }
37397
37398
37399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
37400   void * jresult ;
37401   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37402   Dali::Vector2 *result = 0 ;
37403
37404   arg1 = (Dali::TapGesture *)jarg1;
37405   result = (Dali::Vector2 *)& ((arg1)->localPoint);
37406   jresult = (void *)result;
37407   return jresult;
37408 }
37409
37410
37411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
37412   void * jresult ;
37413   Dali::AlphaFunction *result = 0 ;
37414
37415   {
37416     try {
37417       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
37418     } catch (std::out_of_range& e) {
37419       {
37420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37421       };
37422     } catch (std::exception& e) {
37423       {
37424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37425       };
37426     } catch (...) {
37427       {
37428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37429       };
37430     }
37431   }
37432   jresult = (void *)result;
37433   return jresult;
37434 }
37435
37436
37437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
37438   void * jresult ;
37439   Dali::AlphaFunction::BuiltinFunction arg1 ;
37440   Dali::AlphaFunction *result = 0 ;
37441
37442   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
37443   {
37444     try {
37445       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37446     } catch (std::out_of_range& e) {
37447       {
37448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37449       };
37450     } catch (std::exception& e) {
37451       {
37452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37453       };
37454     } catch (...) {
37455       {
37456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37457       };
37458     }
37459   }
37460   jresult = (void *)result;
37461   return jresult;
37462 }
37463
37464
37465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
37466   void * jresult ;
37467   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
37468   Dali::AlphaFunction *result = 0 ;
37469
37470   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
37471   {
37472     try {
37473       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37474     } catch (std::out_of_range& e) {
37475       {
37476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37477       };
37478     } catch (std::exception& e) {
37479       {
37480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37481       };
37482     } catch (...) {
37483       {
37484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37485       };
37486     }
37487   }
37488   jresult = (void *)result;
37489   return jresult;
37490 }
37491
37492
37493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
37494   void * jresult ;
37495   Dali::Vector2 *arg1 = 0 ;
37496   Dali::Vector2 *arg2 = 0 ;
37497   Dali::AlphaFunction *result = 0 ;
37498
37499   arg1 = (Dali::Vector2 *)jarg1;
37500   if (!arg1) {
37501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37502     return 0;
37503   }
37504   arg2 = (Dali::Vector2 *)jarg2;
37505   if (!arg2) {
37506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37507     return 0;
37508   }
37509   {
37510     try {
37511       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
37512     } catch (std::out_of_range& e) {
37513       {
37514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37515       };
37516     } catch (std::exception& e) {
37517       {
37518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37519       };
37520     } catch (...) {
37521       {
37522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37523       };
37524     }
37525   }
37526   jresult = (void *)result;
37527   return jresult;
37528 }
37529
37530
37531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
37532   void * jresult ;
37533   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37534   Dali::Vector4 result;
37535
37536   arg1 = (Dali::AlphaFunction *)jarg1;
37537   {
37538     try {
37539       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
37540     } catch (std::out_of_range& e) {
37541       {
37542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37543       };
37544     } catch (std::exception& e) {
37545       {
37546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37547       };
37548     } catch (...) {
37549       {
37550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37551       };
37552     }
37553   }
37554   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
37555   return jresult;
37556 }
37557
37558
37559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
37560   void * jresult ;
37561   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37562   Dali::AlphaFunctionPrototype result;
37563
37564   arg1 = (Dali::AlphaFunction *)jarg1;
37565   {
37566     try {
37567       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
37568     } catch (std::out_of_range& e) {
37569       {
37570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37571       };
37572     } catch (std::exception& e) {
37573       {
37574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37575       };
37576     } catch (...) {
37577       {
37578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37579       };
37580     }
37581   }
37582   jresult = (void *)result;
37583   return jresult;
37584 }
37585
37586
37587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
37588   int jresult ;
37589   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37590   Dali::AlphaFunction::BuiltinFunction result;
37591
37592   arg1 = (Dali::AlphaFunction *)jarg1;
37593   {
37594     try {
37595       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
37596     } catch (std::out_of_range& e) {
37597       {
37598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37599       };
37600     } catch (std::exception& e) {
37601       {
37602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37603       };
37604     } catch (...) {
37605       {
37606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37607       };
37608     }
37609   }
37610   jresult = (int)result;
37611   return jresult;
37612 }
37613
37614
37615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
37616   int jresult ;
37617   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37618   Dali::AlphaFunction::Mode result;
37619
37620   arg1 = (Dali::AlphaFunction *)jarg1;
37621   {
37622     try {
37623       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
37624     } catch (std::out_of_range& e) {
37625       {
37626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37627       };
37628     } catch (std::exception& e) {
37629       {
37630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37631       };
37632     } catch (...) {
37633       {
37634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37635       };
37636     }
37637   }
37638   jresult = (int)result;
37639   return jresult;
37640 }
37641
37642
37643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
37644   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37645
37646   arg1 = (Dali::AlphaFunction *)jarg1;
37647   {
37648     try {
37649       delete arg1;
37650     } catch (std::out_of_range& e) {
37651       {
37652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37653       };
37654     } catch (std::exception& e) {
37655       {
37656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37657       };
37658     } catch (...) {
37659       {
37660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37661       };
37662     }
37663   }
37664 }
37665
37666
37667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
37668   void * jresult ;
37669   Dali::KeyFrames result;
37670
37671   {
37672     try {
37673       result = Dali::KeyFrames::New();
37674     } catch (std::out_of_range& e) {
37675       {
37676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37677       };
37678     } catch (std::exception& e) {
37679       {
37680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37681       };
37682     } catch (...) {
37683       {
37684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37685       };
37686     }
37687   }
37688   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37689   return jresult;
37690 }
37691
37692
37693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
37694   void * jresult ;
37695   Dali::BaseHandle arg1 ;
37696   Dali::BaseHandle *argp1 ;
37697   Dali::KeyFrames result;
37698
37699   argp1 = (Dali::BaseHandle *)jarg1;
37700   if (!argp1) {
37701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37702     return 0;
37703   }
37704   arg1 = *argp1;
37705   {
37706     try {
37707       result = Dali::KeyFrames::DownCast(arg1);
37708     } catch (std::out_of_range& e) {
37709       {
37710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37711       };
37712     } catch (std::exception& e) {
37713       {
37714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37715       };
37716     } catch (...) {
37717       {
37718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37719       };
37720     }
37721   }
37722   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37723   return jresult;
37724 }
37725
37726
37727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
37728   void * jresult ;
37729   Dali::KeyFrames *result = 0 ;
37730
37731   {
37732     try {
37733       result = (Dali::KeyFrames *)new Dali::KeyFrames();
37734     } catch (std::out_of_range& e) {
37735       {
37736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37737       };
37738     } catch (std::exception& e) {
37739       {
37740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37741       };
37742     } catch (...) {
37743       {
37744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37745       };
37746     }
37747   }
37748   jresult = (void *)result;
37749   return jresult;
37750 }
37751
37752
37753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
37754   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37755
37756   arg1 = (Dali::KeyFrames *)jarg1;
37757   {
37758     try {
37759       delete arg1;
37760     } catch (std::out_of_range& e) {
37761       {
37762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37763       };
37764     } catch (std::exception& e) {
37765       {
37766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37767       };
37768     } catch (...) {
37769       {
37770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37771       };
37772     }
37773   }
37774 }
37775
37776
37777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
37778   void * jresult ;
37779   Dali::KeyFrames *arg1 = 0 ;
37780   Dali::KeyFrames *result = 0 ;
37781
37782   arg1 = (Dali::KeyFrames *)jarg1;
37783   if (!arg1) {
37784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37785     return 0;
37786   }
37787   {
37788     try {
37789       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
37790     } catch (std::out_of_range& e) {
37791       {
37792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37793       };
37794     } catch (std::exception& e) {
37795       {
37796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37797       };
37798     } catch (...) {
37799       {
37800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37801       };
37802     }
37803   }
37804   jresult = (void *)result;
37805   return jresult;
37806 }
37807
37808
37809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
37810   void * jresult ;
37811   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37812   Dali::KeyFrames *arg2 = 0 ;
37813   Dali::KeyFrames *result = 0 ;
37814
37815   arg1 = (Dali::KeyFrames *)jarg1;
37816   arg2 = (Dali::KeyFrames *)jarg2;
37817   if (!arg2) {
37818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37819     return 0;
37820   }
37821   {
37822     try {
37823       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
37824     } catch (std::out_of_range& e) {
37825       {
37826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37827       };
37828     } catch (std::exception& e) {
37829       {
37830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37831       };
37832     } catch (...) {
37833       {
37834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37835       };
37836     }
37837   }
37838   jresult = (void *)result;
37839   return jresult;
37840 }
37841
37842
37843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
37844   int jresult ;
37845   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37846   Dali::Property::Type result;
37847
37848   arg1 = (Dali::KeyFrames *)jarg1;
37849   {
37850     try {
37851       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
37852     } catch (std::out_of_range& e) {
37853       {
37854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37855       };
37856     } catch (std::exception& e) {
37857       {
37858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37859       };
37860     } catch (...) {
37861       {
37862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37863       };
37864     }
37865   }
37866   jresult = (int)result;
37867   return jresult;
37868 }
37869
37870
37871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
37872   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37873   float arg2 ;
37874   Dali::Property::Value arg3 ;
37875   Dali::Property::Value *argp3 ;
37876
37877   arg1 = (Dali::KeyFrames *)jarg1;
37878   arg2 = (float)jarg2;
37879   argp3 = (Dali::Property::Value *)jarg3;
37880   if (!argp3) {
37881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37882     return ;
37883   }
37884   arg3 = *argp3;
37885   {
37886     try {
37887       (arg1)->Add(arg2,arg3);
37888     } catch (std::out_of_range& e) {
37889       {
37890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37891       };
37892     } catch (std::exception& e) {
37893       {
37894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37895       };
37896     } catch (...) {
37897       {
37898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37899       };
37900     }
37901   }
37902 }
37903
37904
37905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
37906   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37907   float arg2 ;
37908   Dali::Property::Value arg3 ;
37909   Dali::AlphaFunction arg4 ;
37910   Dali::Property::Value *argp3 ;
37911   Dali::AlphaFunction *argp4 ;
37912
37913   arg1 = (Dali::KeyFrames *)jarg1;
37914   arg2 = (float)jarg2;
37915   argp3 = (Dali::Property::Value *)jarg3;
37916   if (!argp3) {
37917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37918     return ;
37919   }
37920   arg3 = *argp3;
37921   argp4 = (Dali::AlphaFunction *)jarg4;
37922   if (!argp4) {
37923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
37924     return ;
37925   }
37926   arg4 = *argp4;
37927   {
37928     try {
37929       (arg1)->Add(arg2,arg3,arg4);
37930     } catch (std::out_of_range& e) {
37931       {
37932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37933       };
37934     } catch (std::exception& e) {
37935       {
37936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37937       };
37938     } catch (...) {
37939       {
37940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37941       };
37942     }
37943   }
37944 }
37945
37946
37947 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
37948   int jresult ;
37949   int result;
37950
37951   result = (int)Dali::Path::Property::POINTS;
37952   jresult = (int)result;
37953   return jresult;
37954 }
37955
37956
37957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
37958   int jresult ;
37959   int result;
37960
37961   result = (int)Dali::Path::Property::CONTROL_POINTS;
37962   jresult = (int)result;
37963   return jresult;
37964 }
37965
37966
37967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
37968   void * jresult ;
37969   Dali::Path::Property *result = 0 ;
37970
37971   {
37972     try {
37973       result = (Dali::Path::Property *)new Dali::Path::Property();
37974     } catch (std::out_of_range& e) {
37975       {
37976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37977       };
37978     } catch (std::exception& e) {
37979       {
37980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37981       };
37982     } catch (...) {
37983       {
37984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37985       };
37986     }
37987   }
37988   jresult = (void *)result;
37989   return jresult;
37990 }
37991
37992
37993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
37994   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
37995
37996   arg1 = (Dali::Path::Property *)jarg1;
37997   {
37998     try {
37999       delete arg1;
38000     } catch (std::out_of_range& e) {
38001       {
38002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38003       };
38004     } catch (std::exception& e) {
38005       {
38006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38007       };
38008     } catch (...) {
38009       {
38010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38011       };
38012     }
38013   }
38014 }
38015
38016
38017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
38018   void * jresult ;
38019   Dali::Path result;
38020
38021   {
38022     try {
38023       result = Dali::Path::New();
38024     } catch (std::out_of_range& e) {
38025       {
38026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38027       };
38028     } catch (std::exception& e) {
38029       {
38030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38031       };
38032     } catch (...) {
38033       {
38034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38035       };
38036     }
38037   }
38038   jresult = new Dali::Path((const Dali::Path &)result);
38039   return jresult;
38040 }
38041
38042
38043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
38044   void * jresult ;
38045   Dali::BaseHandle arg1 ;
38046   Dali::BaseHandle *argp1 ;
38047   Dali::Path result;
38048
38049   argp1 = (Dali::BaseHandle *)jarg1;
38050   if (!argp1) {
38051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38052     return 0;
38053   }
38054   arg1 = *argp1;
38055   {
38056     try {
38057       result = Dali::Path::DownCast(arg1);
38058     } catch (std::out_of_range& e) {
38059       {
38060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38061       };
38062     } catch (std::exception& e) {
38063       {
38064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38065       };
38066     } catch (...) {
38067       {
38068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38069       };
38070     }
38071   }
38072   jresult = new Dali::Path((const Dali::Path &)result);
38073   return jresult;
38074 }
38075
38076
38077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
38078   void * jresult ;
38079   Dali::Path *result = 0 ;
38080
38081   {
38082     try {
38083       result = (Dali::Path *)new Dali::Path();
38084     } catch (std::out_of_range& e) {
38085       {
38086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38087       };
38088     } catch (std::exception& e) {
38089       {
38090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38091       };
38092     } catch (...) {
38093       {
38094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38095       };
38096     }
38097   }
38098   jresult = (void *)result;
38099   return jresult;
38100 }
38101
38102
38103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
38104   Dali::Path *arg1 = (Dali::Path *) 0 ;
38105
38106   arg1 = (Dali::Path *)jarg1;
38107   {
38108     try {
38109       delete arg1;
38110     } catch (std::out_of_range& e) {
38111       {
38112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38113       };
38114     } catch (std::exception& e) {
38115       {
38116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38117       };
38118     } catch (...) {
38119       {
38120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38121       };
38122     }
38123   }
38124 }
38125
38126
38127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
38128   void * jresult ;
38129   Dali::Path *arg1 = 0 ;
38130   Dali::Path *result = 0 ;
38131
38132   arg1 = (Dali::Path *)jarg1;
38133   if (!arg1) {
38134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
38135     return 0;
38136   }
38137   {
38138     try {
38139       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
38140     } catch (std::out_of_range& e) {
38141       {
38142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38143       };
38144     } catch (std::exception& e) {
38145       {
38146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38147       };
38148     } catch (...) {
38149       {
38150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38151       };
38152     }
38153   }
38154   jresult = (void *)result;
38155   return jresult;
38156 }
38157
38158
38159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
38160   void * jresult ;
38161   Dali::Path *arg1 = (Dali::Path *) 0 ;
38162   Dali::Path *arg2 = 0 ;
38163   Dali::Path *result = 0 ;
38164
38165   arg1 = (Dali::Path *)jarg1;
38166   arg2 = (Dali::Path *)jarg2;
38167   if (!arg2) {
38168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
38169     return 0;
38170   }
38171   {
38172     try {
38173       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
38174     } catch (std::out_of_range& e) {
38175       {
38176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38177       };
38178     } catch (std::exception& e) {
38179       {
38180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38181       };
38182     } catch (...) {
38183       {
38184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38185       };
38186     }
38187   }
38188   jresult = (void *)result;
38189   return jresult;
38190 }
38191
38192
38193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
38194   Dali::Path *arg1 = (Dali::Path *) 0 ;
38195   Dali::Vector3 *arg2 = 0 ;
38196
38197   arg1 = (Dali::Path *)jarg1;
38198   arg2 = (Dali::Vector3 *)jarg2;
38199   if (!arg2) {
38200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38201     return ;
38202   }
38203   {
38204     try {
38205       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
38206     } catch (std::out_of_range& e) {
38207       {
38208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38209       };
38210     } catch (std::exception& e) {
38211       {
38212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38213       };
38214     } catch (...) {
38215       {
38216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38217       };
38218     }
38219   }
38220 }
38221
38222
38223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
38224   Dali::Path *arg1 = (Dali::Path *) 0 ;
38225   Dali::Vector3 *arg2 = 0 ;
38226
38227   arg1 = (Dali::Path *)jarg1;
38228   arg2 = (Dali::Vector3 *)jarg2;
38229   if (!arg2) {
38230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38231     return ;
38232   }
38233   {
38234     try {
38235       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
38236     } catch (std::out_of_range& e) {
38237       {
38238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38239       };
38240     } catch (std::exception& e) {
38241       {
38242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38243       };
38244     } catch (...) {
38245       {
38246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38247       };
38248     }
38249   }
38250 }
38251
38252
38253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
38254   Dali::Path *arg1 = (Dali::Path *) 0 ;
38255   float arg2 ;
38256
38257   arg1 = (Dali::Path *)jarg1;
38258   arg2 = (float)jarg2;
38259   {
38260     try {
38261       (arg1)->GenerateControlPoints(arg2);
38262     } catch (std::out_of_range& e) {
38263       {
38264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38265       };
38266     } catch (std::exception& e) {
38267       {
38268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38269       };
38270     } catch (...) {
38271       {
38272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38273       };
38274     }
38275   }
38276 }
38277
38278
38279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
38280   Dali::Path *arg1 = (Dali::Path *) 0 ;
38281   float arg2 ;
38282   Dali::Vector3 *arg3 = 0 ;
38283   Dali::Vector3 *arg4 = 0 ;
38284
38285   arg1 = (Dali::Path *)jarg1;
38286   arg2 = (float)jarg2;
38287   arg3 = (Dali::Vector3 *)jarg3;
38288   if (!arg3) {
38289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38290     return ;
38291   }
38292   arg4 = (Dali::Vector3 *)jarg4;
38293   if (!arg4) {
38294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38295     return ;
38296   }
38297   {
38298     try {
38299       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
38300     } catch (std::out_of_range& e) {
38301       {
38302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38303       };
38304     } catch (std::exception& e) {
38305       {
38306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38307       };
38308     } catch (...) {
38309       {
38310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38311       };
38312     }
38313   }
38314 }
38315
38316
38317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
38318   void * jresult ;
38319   Dali::Path *arg1 = (Dali::Path *) 0 ;
38320   size_t arg2 ;
38321   Dali::Vector3 *result = 0 ;
38322
38323   arg1 = (Dali::Path *)jarg1;
38324   arg2 = (size_t)jarg2;
38325   {
38326     try {
38327       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
38328     } catch (std::out_of_range& e) {
38329       {
38330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38331       };
38332     } catch (std::exception& e) {
38333       {
38334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38335       };
38336     } catch (...) {
38337       {
38338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38339       };
38340     }
38341   }
38342   jresult = (void *)result;
38343   return jresult;
38344 }
38345
38346
38347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
38348   void * jresult ;
38349   Dali::Path *arg1 = (Dali::Path *) 0 ;
38350   size_t arg2 ;
38351   Dali::Vector3 *result = 0 ;
38352
38353   arg1 = (Dali::Path *)jarg1;
38354   arg2 = (size_t)jarg2;
38355   {
38356     try {
38357       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
38358     } catch (std::out_of_range& e) {
38359       {
38360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38361       };
38362     } catch (std::exception& e) {
38363       {
38364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38365       };
38366     } catch (...) {
38367       {
38368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38369       };
38370     }
38371   }
38372   jresult = (void *)result;
38373   return jresult;
38374 }
38375
38376
38377 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
38378   unsigned long jresult ;
38379   Dali::Path *arg1 = (Dali::Path *) 0 ;
38380   size_t result;
38381
38382   arg1 = (Dali::Path *)jarg1;
38383   {
38384     try {
38385       result = ((Dali::Path const *)arg1)->GetPointCount();
38386     } catch (std::out_of_range& e) {
38387       {
38388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38389       };
38390     } catch (std::exception& e) {
38391       {
38392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38393       };
38394     } catch (...) {
38395       {
38396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38397       };
38398     }
38399   }
38400   jresult = (unsigned long)result;
38401   return jresult;
38402 }
38403
38404
38405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
38406   void * jresult ;
38407   float arg1 ;
38408   Dali::TimePeriod *result = 0 ;
38409
38410   arg1 = (float)jarg1;
38411   {
38412     try {
38413       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
38414     } catch (std::out_of_range& e) {
38415       {
38416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38417       };
38418     } catch (std::exception& e) {
38419       {
38420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38421       };
38422     } catch (...) {
38423       {
38424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38425       };
38426     }
38427   }
38428   jresult = (void *)result;
38429   return jresult;
38430 }
38431
38432
38433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
38434   void * jresult ;
38435   float arg1 ;
38436   float arg2 ;
38437   Dali::TimePeriod *result = 0 ;
38438
38439   arg1 = (float)jarg1;
38440   arg2 = (float)jarg2;
38441   {
38442     try {
38443       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
38444     } catch (std::out_of_range& e) {
38445       {
38446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38447       };
38448     } catch (std::exception& e) {
38449       {
38450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38451       };
38452     } catch (...) {
38453       {
38454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38455       };
38456     }
38457   }
38458   jresult = (void *)result;
38459   return jresult;
38460 }
38461
38462
38463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
38464   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38465
38466   arg1 = (Dali::TimePeriod *)jarg1;
38467   {
38468     try {
38469       delete arg1;
38470     } catch (std::out_of_range& e) {
38471       {
38472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38473       };
38474     } catch (std::exception& e) {
38475       {
38476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38477       };
38478     } catch (...) {
38479       {
38480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38481       };
38482     }
38483   }
38484 }
38485
38486
38487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
38488   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38489   float arg2 ;
38490
38491   arg1 = (Dali::TimePeriod *)jarg1;
38492   arg2 = (float)jarg2;
38493   if (arg1) (arg1)->delaySeconds = arg2;
38494 }
38495
38496
38497 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
38498   float jresult ;
38499   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38500   float result;
38501
38502   arg1 = (Dali::TimePeriod *)jarg1;
38503   result = (float) ((arg1)->delaySeconds);
38504   jresult = result;
38505   return jresult;
38506 }
38507
38508
38509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
38510   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38511   float arg2 ;
38512
38513   arg1 = (Dali::TimePeriod *)jarg1;
38514   arg2 = (float)jarg2;
38515   if (arg1) (arg1)->durationSeconds = arg2;
38516 }
38517
38518
38519 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
38520   float jresult ;
38521   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38522   float result;
38523
38524   arg1 = (Dali::TimePeriod *)jarg1;
38525   result = (float) ((arg1)->durationSeconds);
38526   jresult = result;
38527   return jresult;
38528 }
38529
38530
38531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_0() {
38532   void * jresult ;
38533   Dali::Animation *result = 0 ;
38534
38535   {
38536     try {
38537       result = (Dali::Animation *)new Dali::Animation();
38538     } catch (std::out_of_range& e) {
38539       {
38540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38541       };
38542     } catch (std::exception& e) {
38543       {
38544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38545       };
38546     } catch (...) {
38547       {
38548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38549       };
38550     }
38551   }
38552   jresult = (void *)result;
38553   return jresult;
38554 }
38555
38556
38557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_New(float jarg1) {
38558   void * jresult ;
38559   float arg1 ;
38560   Dali::Animation result;
38561
38562   arg1 = (float)jarg1;
38563   {
38564     try {
38565       result = Dali::Animation::New(arg1);
38566     } catch (std::out_of_range& e) {
38567       {
38568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38569       };
38570     } catch (std::exception& e) {
38571       {
38572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38573       };
38574     } catch (...) {
38575       {
38576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38577       };
38578     }
38579   }
38580   jresult = new Dali::Animation((const Dali::Animation &)result);
38581   return jresult;
38582 }
38583
38584
38585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_DownCast(void * jarg1) {
38586   void * jresult ;
38587   Dali::BaseHandle arg1 ;
38588   Dali::BaseHandle *argp1 ;
38589   Dali::Animation result;
38590
38591   argp1 = (Dali::BaseHandle *)jarg1;
38592   if (!argp1) {
38593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38594     return 0;
38595   }
38596   arg1 = *argp1;
38597   {
38598     try {
38599       result = Dali::Animation::DownCast(arg1);
38600     } catch (std::out_of_range& e) {
38601       {
38602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38603       };
38604     } catch (std::exception& e) {
38605       {
38606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38607       };
38608     } catch (...) {
38609       {
38610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38611       };
38612     }
38613   }
38614   jresult = new Dali::Animation((const Dali::Animation &)result);
38615   return jresult;
38616 }
38617
38618
38619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Animation(void * jarg1) {
38620   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38621
38622   arg1 = (Dali::Animation *)jarg1;
38623   {
38624     try {
38625       delete arg1;
38626     } catch (std::out_of_range& e) {
38627       {
38628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38629       };
38630     } catch (std::exception& e) {
38631       {
38632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38633       };
38634     } catch (...) {
38635       {
38636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38637       };
38638     }
38639   }
38640 }
38641
38642
38643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_1(void * jarg1) {
38644   void * jresult ;
38645   Dali::Animation *arg1 = 0 ;
38646   Dali::Animation *result = 0 ;
38647
38648   arg1 = (Dali::Animation *)jarg1;
38649   if (!arg1) {
38650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38651     return 0;
38652   }
38653   {
38654     try {
38655       result = (Dali::Animation *)new Dali::Animation((Dali::Animation const &)*arg1);
38656     } catch (std::out_of_range& e) {
38657       {
38658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38659       };
38660     } catch (std::exception& e) {
38661       {
38662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38663       };
38664     } catch (...) {
38665       {
38666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38667       };
38668     }
38669   }
38670   jresult = (void *)result;
38671   return jresult;
38672 }
38673
38674
38675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_Assign(void * jarg1, void * jarg2) {
38676   void * jresult ;
38677   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38678   Dali::Animation *arg2 = 0 ;
38679   Dali::Animation *result = 0 ;
38680
38681   arg1 = (Dali::Animation *)jarg1;
38682   arg2 = (Dali::Animation *)jarg2;
38683   if (!arg2) {
38684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38685     return 0;
38686   }
38687   {
38688     try {
38689       result = (Dali::Animation *) &(arg1)->operator =((Dali::Animation const &)*arg2);
38690     } catch (std::out_of_range& e) {
38691       {
38692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38693       };
38694     } catch (std::exception& e) {
38695       {
38696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38697       };
38698     } catch (...) {
38699       {
38700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38701       };
38702     }
38703   }
38704   jresult = (void *)result;
38705   return jresult;
38706 }
38707
38708
38709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDuration(void * jarg1, float jarg2) {
38710   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38711   float arg2 ;
38712
38713   arg1 = (Dali::Animation *)jarg1;
38714   arg2 = (float)jarg2;
38715   {
38716     try {
38717       (arg1)->SetDuration(arg2);
38718     } catch (std::out_of_range& e) {
38719       {
38720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38721       };
38722     } catch (std::exception& e) {
38723       {
38724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38725       };
38726     } catch (...) {
38727       {
38728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38729       };
38730     }
38731   }
38732 }
38733
38734
38735 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetDuration(void * jarg1) {
38736   float jresult ;
38737   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38738   float result;
38739
38740   arg1 = (Dali::Animation *)jarg1;
38741   {
38742     try {
38743       result = (float)((Dali::Animation const *)arg1)->GetDuration();
38744     } catch (std::out_of_range& e) {
38745       {
38746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38747       };
38748     } catch (std::exception& e) {
38749       {
38750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38751       };
38752     } catch (...) {
38753       {
38754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38755       };
38756     }
38757   }
38758   jresult = result;
38759   return jresult;
38760 }
38761
38762
38763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLooping(void * jarg1, unsigned int jarg2) {
38764   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38765   bool arg2 ;
38766
38767   arg1 = (Dali::Animation *)jarg1;
38768   arg2 = jarg2 ? true : false;
38769   {
38770     try {
38771       (arg1)->SetLooping(arg2);
38772     } catch (std::out_of_range& e) {
38773       {
38774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38775       };
38776     } catch (std::exception& e) {
38777       {
38778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38779       };
38780     } catch (...) {
38781       {
38782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38783       };
38784     }
38785   }
38786 }
38787
38788
38789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLoopCount(void * jarg1, int jarg2) {
38790   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38791   int arg2 ;
38792
38793   arg1 = (Dali::Animation *)jarg1;
38794   arg2 = (int)jarg2;
38795   {
38796     try {
38797       (arg1)->SetLoopCount(arg2);
38798     } catch (std::out_of_range& e) {
38799       {
38800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38801       };
38802     } catch (std::exception& e) {
38803       {
38804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38805       };
38806     } catch (...) {
38807       {
38808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38809       };
38810     }
38811   }
38812 }
38813
38814
38815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetLoopCount(void * jarg1) {
38816   int jresult ;
38817   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38818   int result;
38819
38820   arg1 = (Dali::Animation *)jarg1;
38821   {
38822     try {
38823       result = (int)(arg1)->GetLoopCount();
38824     } catch (std::out_of_range& e) {
38825       {
38826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38827       };
38828     } catch (std::exception& e) {
38829       {
38830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38831       };
38832     } catch (...) {
38833       {
38834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38835       };
38836     }
38837   }
38838   jresult = result;
38839   return jresult;
38840 }
38841
38842
38843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetCurrentLoop(void * jarg1) {
38844   int jresult ;
38845   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38846   int result;
38847
38848   arg1 = (Dali::Animation *)jarg1;
38849   {
38850     try {
38851       result = (int)(arg1)->GetCurrentLoop();
38852     } catch (std::out_of_range& e) {
38853       {
38854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38855       };
38856     } catch (std::exception& e) {
38857       {
38858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38859       };
38860     } catch (...) {
38861       {
38862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38863       };
38864     }
38865   }
38866   jresult = result;
38867   return jresult;
38868 }
38869
38870
38871 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Animation_IsLooping(void * jarg1) {
38872   unsigned int jresult ;
38873   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38874   bool result;
38875
38876   arg1 = (Dali::Animation *)jarg1;
38877   {
38878     try {
38879       result = (bool)((Dali::Animation const *)arg1)->IsLooping();
38880     } catch (std::out_of_range& e) {
38881       {
38882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38883       };
38884     } catch (std::exception& e) {
38885       {
38886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38887       };
38888     } catch (...) {
38889       {
38890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38891       };
38892     }
38893   }
38894   jresult = result;
38895   return jresult;
38896 }
38897
38898
38899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetEndAction(void * jarg1, int jarg2) {
38900   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38901   Dali::Animation::EndAction arg2 ;
38902
38903   arg1 = (Dali::Animation *)jarg1;
38904   arg2 = (Dali::Animation::EndAction)jarg2;
38905   {
38906     try {
38907       (arg1)->SetEndAction(arg2);
38908     } catch (std::out_of_range& e) {
38909       {
38910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38911       };
38912     } catch (std::exception& e) {
38913       {
38914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38915       };
38916     } catch (...) {
38917       {
38918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38919       };
38920     }
38921   }
38922 }
38923
38924
38925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetEndAction(void * jarg1) {
38926   int jresult ;
38927   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38928   Dali::Animation::EndAction result;
38929
38930   arg1 = (Dali::Animation *)jarg1;
38931   {
38932     try {
38933       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetEndAction();
38934     } catch (std::out_of_range& e) {
38935       {
38936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38937       };
38938     } catch (std::exception& e) {
38939       {
38940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38941       };
38942     } catch (...) {
38943       {
38944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38945       };
38946     }
38947   }
38948   jresult = (int)result;
38949   return jresult;
38950 }
38951
38952
38953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDisconnectAction(void * jarg1, int jarg2) {
38954   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38955   Dali::Animation::EndAction arg2 ;
38956
38957   arg1 = (Dali::Animation *)jarg1;
38958   arg2 = (Dali::Animation::EndAction)jarg2;
38959   {
38960     try {
38961       (arg1)->SetDisconnectAction(arg2);
38962     } catch (std::out_of_range& e) {
38963       {
38964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38965       };
38966     } catch (std::exception& e) {
38967       {
38968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38969       };
38970     } catch (...) {
38971       {
38972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38973       };
38974     }
38975   }
38976 }
38977
38978
38979 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetDisconnectAction(void * jarg1) {
38980   int jresult ;
38981   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38982   Dali::Animation::EndAction result;
38983
38984   arg1 = (Dali::Animation *)jarg1;
38985   {
38986     try {
38987       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetDisconnectAction();
38988     } catch (std::out_of_range& e) {
38989       {
38990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38991       };
38992     } catch (std::exception& e) {
38993       {
38994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38995       };
38996     } catch (...) {
38997       {
38998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38999       };
39000     }
39001   }
39002   jresult = (int)result;
39003   return jresult;
39004 }
39005
39006
39007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDefaultAlphaFunction(void * jarg1, void * jarg2) {
39008   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39009   Dali::AlphaFunction arg2 ;
39010   Dali::AlphaFunction *argp2 ;
39011
39012   arg1 = (Dali::Animation *)jarg1;
39013   argp2 = (Dali::AlphaFunction *)jarg2;
39014   if (!argp2) {
39015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39016     return ;
39017   }
39018   arg2 = *argp2;
39019   {
39020     try {
39021       (arg1)->SetDefaultAlphaFunction(arg2);
39022     } catch (std::out_of_range& e) {
39023       {
39024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39025       };
39026     } catch (std::exception& e) {
39027       {
39028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39029       };
39030     } catch (...) {
39031       {
39032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39033       };
39034     }
39035   }
39036 }
39037
39038
39039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetDefaultAlphaFunction(void * jarg1) {
39040   void * jresult ;
39041   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39042   Dali::AlphaFunction result;
39043
39044   arg1 = (Dali::Animation *)jarg1;
39045   {
39046     try {
39047       result = ((Dali::Animation const *)arg1)->GetDefaultAlphaFunction();
39048     } catch (std::out_of_range& e) {
39049       {
39050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39051       };
39052     } catch (std::exception& e) {
39053       {
39054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39055       };
39056     } catch (...) {
39057       {
39058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39059       };
39060     }
39061   }
39062   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
39063   return jresult;
39064 }
39065
39066
39067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetCurrentProgress(void * jarg1, float jarg2) {
39068   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39069   float arg2 ;
39070
39071   arg1 = (Dali::Animation *)jarg1;
39072   arg2 = (float)jarg2;
39073   {
39074     try {
39075       (arg1)->SetCurrentProgress(arg2);
39076     } catch (std::out_of_range& e) {
39077       {
39078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39079       };
39080     } catch (std::exception& e) {
39081       {
39082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39083       };
39084     } catch (...) {
39085       {
39086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39087       };
39088     }
39089   }
39090 }
39091
39092
39093 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetCurrentProgress(void * jarg1) {
39094   float jresult ;
39095   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39096   float result;
39097
39098   arg1 = (Dali::Animation *)jarg1;
39099   {
39100     try {
39101       result = (float)(arg1)->GetCurrentProgress();
39102     } catch (std::out_of_range& e) {
39103       {
39104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39105       };
39106     } catch (std::exception& e) {
39107       {
39108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39109       };
39110     } catch (...) {
39111       {
39112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39113       };
39114     }
39115   }
39116   jresult = result;
39117   return jresult;
39118 }
39119
39120
39121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetSpeedFactor(void * jarg1, float jarg2) {
39122   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39123   float arg2 ;
39124
39125   arg1 = (Dali::Animation *)jarg1;
39126   arg2 = (float)jarg2;
39127   {
39128     try {
39129       (arg1)->SetSpeedFactor(arg2);
39130     } catch (std::out_of_range& e) {
39131       {
39132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39133       };
39134     } catch (std::exception& e) {
39135       {
39136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39137       };
39138     } catch (...) {
39139       {
39140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39141       };
39142     }
39143   }
39144 }
39145
39146
39147 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetSpeedFactor(void * jarg1) {
39148   float jresult ;
39149   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39150   float result;
39151
39152   arg1 = (Dali::Animation *)jarg1;
39153   {
39154     try {
39155       result = (float)((Dali::Animation const *)arg1)->GetSpeedFactor();
39156     } catch (std::out_of_range& e) {
39157       {
39158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39159       };
39160     } catch (std::exception& e) {
39161       {
39162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39163       };
39164     } catch (...) {
39165       {
39166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39167       };
39168     }
39169   }
39170   jresult = result;
39171   return jresult;
39172 }
39173
39174
39175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetPlayRange(void * jarg1, void * jarg2) {
39176   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39177   Dali::Vector2 *arg2 = 0 ;
39178
39179   arg1 = (Dali::Animation *)jarg1;
39180   arg2 = (Dali::Vector2 *)jarg2;
39181   if (!arg2) {
39182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39183     return ;
39184   }
39185   {
39186     try {
39187       (arg1)->SetPlayRange((Dali::Vector2 const &)*arg2);
39188     } catch (std::out_of_range& e) {
39189       {
39190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39191       };
39192     } catch (std::exception& e) {
39193       {
39194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39195       };
39196     } catch (...) {
39197       {
39198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39199       };
39200     }
39201   }
39202 }
39203
39204
39205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetPlayRange(void * jarg1) {
39206   void * jresult ;
39207   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39208   Dali::Vector2 result;
39209
39210   arg1 = (Dali::Animation *)jarg1;
39211   {
39212     try {
39213       result = ((Dali::Animation const *)arg1)->GetPlayRange();
39214     } catch (std::out_of_range& e) {
39215       {
39216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39217       };
39218     } catch (std::exception& e) {
39219       {
39220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39221       };
39222     } catch (...) {
39223       {
39224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39225       };
39226     }
39227   }
39228   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
39229   return jresult;
39230 }
39231
39232
39233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Play(void * jarg1) {
39234   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39235
39236   arg1 = (Dali::Animation *)jarg1;
39237   {
39238     try {
39239       (arg1)->Play();
39240     } catch (std::out_of_range& e) {
39241       {
39242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39243       };
39244     } catch (std::exception& e) {
39245       {
39246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39247       };
39248     } catch (...) {
39249       {
39250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39251       };
39252     }
39253   }
39254 }
39255
39256
39257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_PlayFrom(void * jarg1, float jarg2) {
39258   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39259   float arg2 ;
39260
39261   arg1 = (Dali::Animation *)jarg1;
39262   arg2 = (float)jarg2;
39263   {
39264     try {
39265       (arg1)->PlayFrom(arg2);
39266     } catch (std::out_of_range& e) {
39267       {
39268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39269       };
39270     } catch (std::exception& e) {
39271       {
39272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39273       };
39274     } catch (...) {
39275       {
39276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39277       };
39278     }
39279   }
39280 }
39281
39282
39283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Pause(void * jarg1) {
39284   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39285
39286   arg1 = (Dali::Animation *)jarg1;
39287   {
39288     try {
39289       (arg1)->Pause();
39290     } catch (std::out_of_range& e) {
39291       {
39292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39293       };
39294     } catch (std::exception& e) {
39295       {
39296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39297       };
39298     } catch (...) {
39299       {
39300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39301       };
39302     }
39303   }
39304 }
39305
39306
39307 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetState(void * jarg1) {
39308   int jresult ;
39309   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39310   Dali::Animation::State result;
39311
39312   arg1 = (Dali::Animation *)jarg1;
39313   {
39314     try {
39315       result = (Dali::Animation::State)((Dali::Animation const *)arg1)->GetState();
39316     } catch (std::out_of_range& e) {
39317       {
39318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39319       };
39320     } catch (std::exception& e) {
39321       {
39322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39323       };
39324     } catch (...) {
39325       {
39326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39327       };
39328     }
39329   }
39330   jresult = (int)result;
39331   return jresult;
39332 }
39333
39334
39335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Stop(void * jarg1) {
39336   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39337
39338   arg1 = (Dali::Animation *)jarg1;
39339   {
39340     try {
39341       (arg1)->Stop();
39342     } catch (std::out_of_range& e) {
39343       {
39344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39345       };
39346     } catch (std::exception& e) {
39347       {
39348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39349       };
39350     } catch (...) {
39351       {
39352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39353       };
39354     }
39355   }
39356 }
39357
39358
39359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Clear(void * jarg1) {
39360   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39361
39362   arg1 = (Dali::Animation *)jarg1;
39363   {
39364     try {
39365       (arg1)->Clear();
39366     } catch (std::out_of_range& e) {
39367       {
39368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39369       };
39370     } catch (std::exception& e) {
39371       {
39372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39373       };
39374     } catch (...) {
39375       {
39376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39377       };
39378     }
39379   }
39380 }
39381
39382
39383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_FinishedSignal(void * jarg1) {
39384   void * jresult ;
39385   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39386   Dali::Animation::AnimationSignalType *result = 0 ;
39387
39388   arg1 = (Dali::Animation *)jarg1;
39389   {
39390     try {
39391       result = (Dali::Animation::AnimationSignalType *) &(arg1)->FinishedSignal();
39392     } catch (std::out_of_range& e) {
39393       {
39394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39395       };
39396     } catch (std::exception& e) {
39397       {
39398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39399       };
39400     } catch (...) {
39401       {
39402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39403       };
39404     }
39405   }
39406   jresult = (void *)result;
39407   return jresult;
39408 }
39409
39410
39411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39412   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39413   SwigValueWrapper< Dali::Property > arg2 ;
39414   Dali::Property::Value arg3 ;
39415   Dali::Property *argp2 ;
39416   Dali::Property::Value *argp3 ;
39417
39418   arg1 = (Dali::Animation *)jarg1;
39419   argp2 = (Dali::Property *)jarg2;
39420   if (!argp2) {
39421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39422     return ;
39423   }
39424   arg2 = *argp2;
39425   argp3 = (Dali::Property::Value *)jarg3;
39426   if (!argp3) {
39427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39428     return ;
39429   }
39430   arg3 = *argp3;
39431   {
39432     try {
39433       (arg1)->AnimateBy(arg2,arg3);
39434     } catch (std::out_of_range& e) {
39435       {
39436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39437       };
39438     } catch (std::exception& e) {
39439       {
39440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39441       };
39442     } catch (...) {
39443       {
39444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39445       };
39446     }
39447   }
39448 }
39449
39450
39451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39452   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39453   SwigValueWrapper< Dali::Property > arg2 ;
39454   Dali::Property::Value arg3 ;
39455   Dali::AlphaFunction arg4 ;
39456   Dali::Property *argp2 ;
39457   Dali::Property::Value *argp3 ;
39458   Dali::AlphaFunction *argp4 ;
39459
39460   arg1 = (Dali::Animation *)jarg1;
39461   argp2 = (Dali::Property *)jarg2;
39462   if (!argp2) {
39463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39464     return ;
39465   }
39466   arg2 = *argp2;
39467   argp3 = (Dali::Property::Value *)jarg3;
39468   if (!argp3) {
39469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39470     return ;
39471   }
39472   arg3 = *argp3;
39473   argp4 = (Dali::AlphaFunction *)jarg4;
39474   if (!argp4) {
39475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39476     return ;
39477   }
39478   arg4 = *argp4;
39479   {
39480     try {
39481       (arg1)->AnimateBy(arg2,arg3,arg4);
39482     } catch (std::out_of_range& e) {
39483       {
39484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39485       };
39486     } catch (std::exception& e) {
39487       {
39488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39489       };
39490     } catch (...) {
39491       {
39492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39493       };
39494     }
39495   }
39496 }
39497
39498
39499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39500   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39501   SwigValueWrapper< Dali::Property > arg2 ;
39502   Dali::Property::Value arg3 ;
39503   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39504   Dali::Property *argp2 ;
39505   Dali::Property::Value *argp3 ;
39506   Dali::TimePeriod *argp4 ;
39507
39508   arg1 = (Dali::Animation *)jarg1;
39509   argp2 = (Dali::Property *)jarg2;
39510   if (!argp2) {
39511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39512     return ;
39513   }
39514   arg2 = *argp2;
39515   argp3 = (Dali::Property::Value *)jarg3;
39516   if (!argp3) {
39517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39518     return ;
39519   }
39520   arg3 = *argp3;
39521   argp4 = (Dali::TimePeriod *)jarg4;
39522   if (!argp4) {
39523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39524     return ;
39525   }
39526   arg4 = *argp4;
39527   {
39528     try {
39529       (arg1)->AnimateBy(arg2,arg3,arg4);
39530     } catch (std::out_of_range& e) {
39531       {
39532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39533       };
39534     } catch (std::exception& e) {
39535       {
39536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39537       };
39538     } catch (...) {
39539       {
39540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39541       };
39542     }
39543   }
39544 }
39545
39546
39547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39548   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39549   SwigValueWrapper< Dali::Property > arg2 ;
39550   Dali::Property::Value arg3 ;
39551   Dali::AlphaFunction arg4 ;
39552   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39553   Dali::Property *argp2 ;
39554   Dali::Property::Value *argp3 ;
39555   Dali::AlphaFunction *argp4 ;
39556   Dali::TimePeriod *argp5 ;
39557
39558   arg1 = (Dali::Animation *)jarg1;
39559   argp2 = (Dali::Property *)jarg2;
39560   if (!argp2) {
39561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39562     return ;
39563   }
39564   arg2 = *argp2;
39565   argp3 = (Dali::Property::Value *)jarg3;
39566   if (!argp3) {
39567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39568     return ;
39569   }
39570   arg3 = *argp3;
39571   argp4 = (Dali::AlphaFunction *)jarg4;
39572   if (!argp4) {
39573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39574     return ;
39575   }
39576   arg4 = *argp4;
39577   argp5 = (Dali::TimePeriod *)jarg5;
39578   if (!argp5) {
39579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39580     return ;
39581   }
39582   arg5 = *argp5;
39583   {
39584     try {
39585       (arg1)->AnimateBy(arg2,arg3,arg4,arg5);
39586     } catch (std::out_of_range& e) {
39587       {
39588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39589       };
39590     } catch (std::exception& e) {
39591       {
39592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39593       };
39594     } catch (...) {
39595       {
39596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39597       };
39598     }
39599   }
39600 }
39601
39602
39603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39604   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39605   SwigValueWrapper< Dali::Property > arg2 ;
39606   Dali::Property::Value arg3 ;
39607   Dali::Property *argp2 ;
39608   Dali::Property::Value *argp3 ;
39609
39610   arg1 = (Dali::Animation *)jarg1;
39611   argp2 = (Dali::Property *)jarg2;
39612   if (!argp2) {
39613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39614     return ;
39615   }
39616   arg2 = *argp2;
39617   argp3 = (Dali::Property::Value *)jarg3;
39618   if (!argp3) {
39619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39620     return ;
39621   }
39622   arg3 = *argp3;
39623   {
39624     try {
39625       (arg1)->AnimateTo(arg2,arg3);
39626     } catch (std::out_of_range& e) {
39627       {
39628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39629       };
39630     } catch (std::exception& e) {
39631       {
39632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39633       };
39634     } catch (...) {
39635       {
39636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39637       };
39638     }
39639   }
39640 }
39641
39642
39643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39644   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39645   SwigValueWrapper< Dali::Property > arg2 ;
39646   Dali::Property::Value arg3 ;
39647   Dali::AlphaFunction arg4 ;
39648   Dali::Property *argp2 ;
39649   Dali::Property::Value *argp3 ;
39650   Dali::AlphaFunction *argp4 ;
39651
39652   arg1 = (Dali::Animation *)jarg1;
39653   argp2 = (Dali::Property *)jarg2;
39654   if (!argp2) {
39655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39656     return ;
39657   }
39658   arg2 = *argp2;
39659   argp3 = (Dali::Property::Value *)jarg3;
39660   if (!argp3) {
39661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39662     return ;
39663   }
39664   arg3 = *argp3;
39665   argp4 = (Dali::AlphaFunction *)jarg4;
39666   if (!argp4) {
39667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39668     return ;
39669   }
39670   arg4 = *argp4;
39671   {
39672     try {
39673       (arg1)->AnimateTo(arg2,arg3,arg4);
39674     } catch (std::out_of_range& e) {
39675       {
39676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39677       };
39678     } catch (std::exception& e) {
39679       {
39680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39681       };
39682     } catch (...) {
39683       {
39684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39685       };
39686     }
39687   }
39688 }
39689
39690
39691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39692   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39693   SwigValueWrapper< Dali::Property > arg2 ;
39694   Dali::Property::Value arg3 ;
39695   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39696   Dali::Property *argp2 ;
39697   Dali::Property::Value *argp3 ;
39698   Dali::TimePeriod *argp4 ;
39699
39700   arg1 = (Dali::Animation *)jarg1;
39701   argp2 = (Dali::Property *)jarg2;
39702   if (!argp2) {
39703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39704     return ;
39705   }
39706   arg2 = *argp2;
39707   argp3 = (Dali::Property::Value *)jarg3;
39708   if (!argp3) {
39709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39710     return ;
39711   }
39712   arg3 = *argp3;
39713   argp4 = (Dali::TimePeriod *)jarg4;
39714   if (!argp4) {
39715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39716     return ;
39717   }
39718   arg4 = *argp4;
39719   {
39720     try {
39721       (arg1)->AnimateTo(arg2,arg3,arg4);
39722     } catch (std::out_of_range& e) {
39723       {
39724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39725       };
39726     } catch (std::exception& e) {
39727       {
39728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39729       };
39730     } catch (...) {
39731       {
39732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39733       };
39734     }
39735   }
39736 }
39737
39738
39739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39740   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39741   SwigValueWrapper< Dali::Property > arg2 ;
39742   Dali::Property::Value arg3 ;
39743   Dali::AlphaFunction arg4 ;
39744   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39745   Dali::Property *argp2 ;
39746   Dali::Property::Value *argp3 ;
39747   Dali::AlphaFunction *argp4 ;
39748   Dali::TimePeriod *argp5 ;
39749
39750   arg1 = (Dali::Animation *)jarg1;
39751   argp2 = (Dali::Property *)jarg2;
39752   if (!argp2) {
39753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39754     return ;
39755   }
39756   arg2 = *argp2;
39757   argp3 = (Dali::Property::Value *)jarg3;
39758   if (!argp3) {
39759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39760     return ;
39761   }
39762   arg3 = *argp3;
39763   argp4 = (Dali::AlphaFunction *)jarg4;
39764   if (!argp4) {
39765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39766     return ;
39767   }
39768   arg4 = *argp4;
39769   argp5 = (Dali::TimePeriod *)jarg5;
39770   if (!argp5) {
39771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39772     return ;
39773   }
39774   arg5 = *argp5;
39775   {
39776     try {
39777       (arg1)->AnimateTo(arg2,arg3,arg4,arg5);
39778     } catch (std::out_of_range& e) {
39779       {
39780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39781       };
39782     } catch (std::exception& e) {
39783       {
39784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39785       };
39786     } catch (...) {
39787       {
39788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39789       };
39790     }
39791   }
39792 }
39793
39794
39795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39796   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39797   SwigValueWrapper< Dali::Property > arg2 ;
39798   Dali::KeyFrames *arg3 = 0 ;
39799   Dali::Property *argp2 ;
39800
39801   arg1 = (Dali::Animation *)jarg1;
39802   argp2 = (Dali::Property *)jarg2;
39803   if (!argp2) {
39804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39805     return ;
39806   }
39807   arg2 = *argp2;
39808   arg3 = (Dali::KeyFrames *)jarg3;
39809   if (!arg3) {
39810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39811     return ;
39812   }
39813   {
39814     try {
39815       (arg1)->AnimateBetween(arg2,*arg3);
39816     } catch (std::out_of_range& e) {
39817       {
39818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39819       };
39820     } catch (std::exception& e) {
39821       {
39822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39823       };
39824     } catch (...) {
39825       {
39826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39827       };
39828     }
39829   }
39830 }
39831
39832
39833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_1(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
39834   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39835   SwigValueWrapper< Dali::Property > arg2 ;
39836   Dali::KeyFrames *arg3 = 0 ;
39837   Dali::Animation::Interpolation arg4 ;
39838   Dali::Property *argp2 ;
39839
39840   arg1 = (Dali::Animation *)jarg1;
39841   argp2 = (Dali::Property *)jarg2;
39842   if (!argp2) {
39843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39844     return ;
39845   }
39846   arg2 = *argp2;
39847   arg3 = (Dali::KeyFrames *)jarg3;
39848   if (!arg3) {
39849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39850     return ;
39851   }
39852   arg4 = (Dali::Animation::Interpolation)jarg4;
39853   {
39854     try {
39855       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39856     } catch (std::out_of_range& e) {
39857       {
39858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39859       };
39860     } catch (std::exception& e) {
39861       {
39862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39863       };
39864     } catch (...) {
39865       {
39866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39867       };
39868     }
39869   }
39870 }
39871
39872
39873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39874   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39875   SwigValueWrapper< Dali::Property > arg2 ;
39876   Dali::KeyFrames *arg3 = 0 ;
39877   Dali::AlphaFunction arg4 ;
39878   Dali::Property *argp2 ;
39879   Dali::AlphaFunction *argp4 ;
39880
39881   arg1 = (Dali::Animation *)jarg1;
39882   argp2 = (Dali::Property *)jarg2;
39883   if (!argp2) {
39884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39885     return ;
39886   }
39887   arg2 = *argp2;
39888   arg3 = (Dali::KeyFrames *)jarg3;
39889   if (!arg3) {
39890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39891     return ;
39892   }
39893   argp4 = (Dali::AlphaFunction *)jarg4;
39894   if (!argp4) {
39895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39896     return ;
39897   }
39898   arg4 = *argp4;
39899   {
39900     try {
39901       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39902     } catch (std::out_of_range& e) {
39903       {
39904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39905       };
39906     } catch (std::exception& e) {
39907       {
39908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39909       };
39910     } catch (...) {
39911       {
39912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39913       };
39914     }
39915   }
39916 }
39917
39918
39919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
39920   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39921   SwigValueWrapper< Dali::Property > arg2 ;
39922   Dali::KeyFrames *arg3 = 0 ;
39923   Dali::AlphaFunction arg4 ;
39924   Dali::Animation::Interpolation arg5 ;
39925   Dali::Property *argp2 ;
39926   Dali::AlphaFunction *argp4 ;
39927
39928   arg1 = (Dali::Animation *)jarg1;
39929   argp2 = (Dali::Property *)jarg2;
39930   if (!argp2) {
39931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39932     return ;
39933   }
39934   arg2 = *argp2;
39935   arg3 = (Dali::KeyFrames *)jarg3;
39936   if (!arg3) {
39937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39938     return ;
39939   }
39940   argp4 = (Dali::AlphaFunction *)jarg4;
39941   if (!argp4) {
39942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39943     return ;
39944   }
39945   arg4 = *argp4;
39946   arg5 = (Dali::Animation::Interpolation)jarg5;
39947   {
39948     try {
39949       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
39950     } catch (std::out_of_range& e) {
39951       {
39952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39953       };
39954     } catch (std::exception& e) {
39955       {
39956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39957       };
39958     } catch (...) {
39959       {
39960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39961       };
39962     }
39963   }
39964 }
39965
39966
39967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39968   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39969   SwigValueWrapper< Dali::Property > arg2 ;
39970   Dali::KeyFrames *arg3 = 0 ;
39971   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39972   Dali::Property *argp2 ;
39973   Dali::TimePeriod *argp4 ;
39974
39975   arg1 = (Dali::Animation *)jarg1;
39976   argp2 = (Dali::Property *)jarg2;
39977   if (!argp2) {
39978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39979     return ;
39980   }
39981   arg2 = *argp2;
39982   arg3 = (Dali::KeyFrames *)jarg3;
39983   if (!arg3) {
39984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39985     return ;
39986   }
39987   argp4 = (Dali::TimePeriod *)jarg4;
39988   if (!argp4) {
39989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39990     return ;
39991   }
39992   arg4 = *argp4;
39993   {
39994     try {
39995       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39996     } catch (std::out_of_range& e) {
39997       {
39998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39999       };
40000     } catch (std::exception& e) {
40001       {
40002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40003       };
40004     } catch (...) {
40005       {
40006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40007       };
40008     }
40009   }
40010 }
40011
40012
40013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
40014   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40015   SwigValueWrapper< Dali::Property > arg2 ;
40016   Dali::KeyFrames *arg3 = 0 ;
40017   SwigValueWrapper< Dali::TimePeriod > arg4 ;
40018   Dali::Animation::Interpolation arg5 ;
40019   Dali::Property *argp2 ;
40020   Dali::TimePeriod *argp4 ;
40021
40022   arg1 = (Dali::Animation *)jarg1;
40023   argp2 = (Dali::Property *)jarg2;
40024   if (!argp2) {
40025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40026     return ;
40027   }
40028   arg2 = *argp2;
40029   arg3 = (Dali::KeyFrames *)jarg3;
40030   if (!arg3) {
40031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40032     return ;
40033   }
40034   argp4 = (Dali::TimePeriod *)jarg4;
40035   if (!argp4) {
40036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40037     return ;
40038   }
40039   arg4 = *argp4;
40040   arg5 = (Dali::Animation::Interpolation)jarg5;
40041   {
40042     try {
40043       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
40044     } catch (std::out_of_range& e) {
40045       {
40046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40047       };
40048     } catch (std::exception& e) {
40049       {
40050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40051       };
40052     } catch (...) {
40053       {
40054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40055       };
40056     }
40057   }
40058 }
40059
40060
40061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40062   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40063   SwigValueWrapper< Dali::Property > arg2 ;
40064   Dali::KeyFrames *arg3 = 0 ;
40065   Dali::AlphaFunction arg4 ;
40066   SwigValueWrapper< Dali::TimePeriod > arg5 ;
40067   Dali::Property *argp2 ;
40068   Dali::AlphaFunction *argp4 ;
40069   Dali::TimePeriod *argp5 ;
40070
40071   arg1 = (Dali::Animation *)jarg1;
40072   argp2 = (Dali::Property *)jarg2;
40073   if (!argp2) {
40074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40075     return ;
40076   }
40077   arg2 = *argp2;
40078   arg3 = (Dali::KeyFrames *)jarg3;
40079   if (!arg3) {
40080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40081     return ;
40082   }
40083   argp4 = (Dali::AlphaFunction *)jarg4;
40084   if (!argp4) {
40085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40086     return ;
40087   }
40088   arg4 = *argp4;
40089   argp5 = (Dali::TimePeriod *)jarg5;
40090   if (!argp5) {
40091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40092     return ;
40093   }
40094   arg5 = *argp5;
40095   {
40096     try {
40097       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
40098     } catch (std::out_of_range& e) {
40099       {
40100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40101       };
40102     } catch (std::exception& e) {
40103       {
40104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40105       };
40106     } catch (...) {
40107       {
40108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40109       };
40110     }
40111   }
40112 }
40113
40114
40115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_7(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
40116   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40117   SwigValueWrapper< Dali::Property > arg2 ;
40118   Dali::KeyFrames *arg3 = 0 ;
40119   Dali::AlphaFunction arg4 ;
40120   SwigValueWrapper< Dali::TimePeriod > arg5 ;
40121   Dali::Animation::Interpolation arg6 ;
40122   Dali::Property *argp2 ;
40123   Dali::AlphaFunction *argp4 ;
40124   Dali::TimePeriod *argp5 ;
40125
40126   arg1 = (Dali::Animation *)jarg1;
40127   argp2 = (Dali::Property *)jarg2;
40128   if (!argp2) {
40129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40130     return ;
40131   }
40132   arg2 = *argp2;
40133   arg3 = (Dali::KeyFrames *)jarg3;
40134   if (!arg3) {
40135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40136     return ;
40137   }
40138   argp4 = (Dali::AlphaFunction *)jarg4;
40139   if (!argp4) {
40140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40141     return ;
40142   }
40143   arg4 = *argp4;
40144   argp5 = (Dali::TimePeriod *)jarg5;
40145   if (!argp5) {
40146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40147     return ;
40148   }
40149   arg5 = *argp5;
40150   arg6 = (Dali::Animation::Interpolation)jarg6;
40151   {
40152     try {
40153       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5,arg6);
40154     } catch (std::out_of_range& e) {
40155       {
40156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40157       };
40158     } catch (std::exception& e) {
40159       {
40160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40161       };
40162     } catch (...) {
40163       {
40164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40165       };
40166     }
40167   }
40168 }
40169
40170
40171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40172   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40173   Dali::Actor arg2 ;
40174   Dali::Path arg3 ;
40175   Dali::Vector3 *arg4 = 0 ;
40176   Dali::Actor *argp2 ;
40177   Dali::Path *argp3 ;
40178
40179   arg1 = (Dali::Animation *)jarg1;
40180   argp2 = (Dali::Actor *)jarg2;
40181   if (!argp2) {
40182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40183     return ;
40184   }
40185   arg2 = *argp2;
40186   argp3 = (Dali::Path *)jarg3;
40187   if (!argp3) {
40188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40189     return ;
40190   }
40191   arg3 = *argp3;
40192   arg4 = (Dali::Vector3 *)jarg4;
40193   if (!arg4) {
40194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40195     return ;
40196   }
40197   {
40198     try {
40199       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4);
40200     } catch (std::out_of_range& e) {
40201       {
40202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40203       };
40204     } catch (std::exception& e) {
40205       {
40206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40207       };
40208     } catch (...) {
40209       {
40210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40211       };
40212     }
40213   }
40214 }
40215
40216
40217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40218   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40219   Dali::Actor arg2 ;
40220   Dali::Path arg3 ;
40221   Dali::Vector3 *arg4 = 0 ;
40222   Dali::AlphaFunction arg5 ;
40223   Dali::Actor *argp2 ;
40224   Dali::Path *argp3 ;
40225   Dali::AlphaFunction *argp5 ;
40226
40227   arg1 = (Dali::Animation *)jarg1;
40228   argp2 = (Dali::Actor *)jarg2;
40229   if (!argp2) {
40230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40231     return ;
40232   }
40233   arg2 = *argp2;
40234   argp3 = (Dali::Path *)jarg3;
40235   if (!argp3) {
40236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40237     return ;
40238   }
40239   arg3 = *argp3;
40240   arg4 = (Dali::Vector3 *)jarg4;
40241   if (!arg4) {
40242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40243     return ;
40244   }
40245   argp5 = (Dali::AlphaFunction *)jarg5;
40246   if (!argp5) {
40247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40248     return ;
40249   }
40250   arg5 = *argp5;
40251   {
40252     try {
40253       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
40254     } catch (std::out_of_range& e) {
40255       {
40256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40257       };
40258     } catch (std::exception& e) {
40259       {
40260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40261       };
40262     } catch (...) {
40263       {
40264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40265       };
40266     }
40267   }
40268 }
40269
40270
40271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40272   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40273   Dali::Actor arg2 ;
40274   Dali::Path arg3 ;
40275   Dali::Vector3 *arg4 = 0 ;
40276   SwigValueWrapper< Dali::TimePeriod > arg5 ;
40277   Dali::Actor *argp2 ;
40278   Dali::Path *argp3 ;
40279   Dali::TimePeriod *argp5 ;
40280
40281   arg1 = (Dali::Animation *)jarg1;
40282   argp2 = (Dali::Actor *)jarg2;
40283   if (!argp2) {
40284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40285     return ;
40286   }
40287   arg2 = *argp2;
40288   argp3 = (Dali::Path *)jarg3;
40289   if (!argp3) {
40290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40291     return ;
40292   }
40293   arg3 = *argp3;
40294   arg4 = (Dali::Vector3 *)jarg4;
40295   if (!arg4) {
40296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40297     return ;
40298   }
40299   argp5 = (Dali::TimePeriod *)jarg5;
40300   if (!argp5) {
40301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40302     return ;
40303   }
40304   arg5 = *argp5;
40305   {
40306     try {
40307       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
40308     } catch (std::out_of_range& e) {
40309       {
40310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40311       };
40312     } catch (std::exception& e) {
40313       {
40314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40315       };
40316     } catch (...) {
40317       {
40318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40319       };
40320     }
40321   }
40322 }
40323
40324
40325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
40326   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40327   Dali::Actor arg2 ;
40328   Dali::Path arg3 ;
40329   Dali::Vector3 *arg4 = 0 ;
40330   Dali::AlphaFunction arg5 ;
40331   SwigValueWrapper< Dali::TimePeriod > arg6 ;
40332   Dali::Actor *argp2 ;
40333   Dali::Path *argp3 ;
40334   Dali::AlphaFunction *argp5 ;
40335   Dali::TimePeriod *argp6 ;
40336
40337   arg1 = (Dali::Animation *)jarg1;
40338   argp2 = (Dali::Actor *)jarg2;
40339   if (!argp2) {
40340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40341     return ;
40342   }
40343   arg2 = *argp2;
40344   argp3 = (Dali::Path *)jarg3;
40345   if (!argp3) {
40346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40347     return ;
40348   }
40349   arg3 = *argp3;
40350   arg4 = (Dali::Vector3 *)jarg4;
40351   if (!arg4) {
40352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40353     return ;
40354   }
40355   argp5 = (Dali::AlphaFunction *)jarg5;
40356   if (!argp5) {
40357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40358     return ;
40359   }
40360   arg5 = *argp5;
40361   argp6 = (Dali::TimePeriod *)jarg6;
40362   if (!argp6) {
40363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40364     return ;
40365   }
40366   arg6 = *argp6;
40367   {
40368     try {
40369       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5,arg6);
40370     } catch (std::out_of_range& e) {
40371       {
40372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40373       };
40374     } catch (std::exception& e) {
40375       {
40376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40377       };
40378     } catch (...) {
40379       {
40380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40381       };
40382     }
40383   }
40384 }
40385
40386
40387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Show(void * jarg1, void * jarg2, float jarg3) {
40388   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40389   Dali::Actor arg2 ;
40390   float arg3 ;
40391   Dali::Actor *argp2 ;
40392
40393   arg1 = (Dali::Animation *)jarg1;
40394   argp2 = (Dali::Actor *)jarg2;
40395   if (!argp2) {
40396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40397     return ;
40398   }
40399   arg2 = *argp2;
40400   arg3 = (float)jarg3;
40401   {
40402     try {
40403       (arg1)->Show(arg2,arg3);
40404     } catch (std::out_of_range& e) {
40405       {
40406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40407       };
40408     } catch (std::exception& e) {
40409       {
40410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40411       };
40412     } catch (...) {
40413       {
40414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40415       };
40416     }
40417   }
40418 }
40419
40420
40421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Hide(void * jarg1, void * jarg2, float jarg3) {
40422   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40423   Dali::Actor arg2 ;
40424   float arg3 ;
40425   Dali::Actor *argp2 ;
40426
40427   arg1 = (Dali::Animation *)jarg1;
40428   argp2 = (Dali::Actor *)jarg2;
40429   if (!argp2) {
40430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40431     return ;
40432   }
40433   arg2 = *argp2;
40434   arg3 = (float)jarg3;
40435   {
40436     try {
40437       (arg1)->Hide(arg2,arg3);
40438     } catch (std::out_of_range& e) {
40439       {
40440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40441       };
40442     } catch (std::exception& e) {
40443       {
40444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40445       };
40446     } catch (...) {
40447       {
40448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40449       };
40450     }
40451   }
40452 }
40453
40454
40455 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
40456   int jresult ;
40457   int result;
40458
40459   result = (int)Dali::LinearConstrainer::Property::VALUE;
40460   jresult = (int)result;
40461   return jresult;
40462 }
40463
40464
40465 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
40466   int jresult ;
40467   int result;
40468
40469   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
40470   jresult = (int)result;
40471   return jresult;
40472 }
40473
40474
40475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
40476   void * jresult ;
40477   Dali::LinearConstrainer::Property *result = 0 ;
40478
40479   {
40480     try {
40481       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
40482     } catch (std::out_of_range& e) {
40483       {
40484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40485       };
40486     } catch (std::exception& e) {
40487       {
40488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40489       };
40490     } catch (...) {
40491       {
40492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40493       };
40494     }
40495   }
40496   jresult = (void *)result;
40497   return jresult;
40498 }
40499
40500
40501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
40502   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
40503
40504   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
40505   {
40506     try {
40507       delete arg1;
40508     } catch (std::out_of_range& e) {
40509       {
40510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40511       };
40512     } catch (std::exception& e) {
40513       {
40514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40515       };
40516     } catch (...) {
40517       {
40518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40519       };
40520     }
40521   }
40522 }
40523
40524
40525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
40526   void * jresult ;
40527   Dali::LinearConstrainer result;
40528
40529   {
40530     try {
40531       result = Dali::LinearConstrainer::New();
40532     } catch (std::out_of_range& e) {
40533       {
40534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40535       };
40536     } catch (std::exception& e) {
40537       {
40538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40539       };
40540     } catch (...) {
40541       {
40542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40543       };
40544     }
40545   }
40546   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40547   return jresult;
40548 }
40549
40550
40551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
40552   void * jresult ;
40553   Dali::BaseHandle arg1 ;
40554   Dali::BaseHandle *argp1 ;
40555   Dali::LinearConstrainer result;
40556
40557   argp1 = (Dali::BaseHandle *)jarg1;
40558   if (!argp1) {
40559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40560     return 0;
40561   }
40562   arg1 = *argp1;
40563   {
40564     try {
40565       result = Dali::LinearConstrainer::DownCast(arg1);
40566     } catch (std::out_of_range& e) {
40567       {
40568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40569       };
40570     } catch (std::exception& e) {
40571       {
40572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40573       };
40574     } catch (...) {
40575       {
40576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40577       };
40578     }
40579   }
40580   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40581   return jresult;
40582 }
40583
40584
40585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
40586   void * jresult ;
40587   Dali::LinearConstrainer *result = 0 ;
40588
40589   {
40590     try {
40591       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
40592     } catch (std::out_of_range& e) {
40593       {
40594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40595       };
40596     } catch (std::exception& e) {
40597       {
40598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40599       };
40600     } catch (...) {
40601       {
40602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40603       };
40604     }
40605   }
40606   jresult = (void *)result;
40607   return jresult;
40608 }
40609
40610
40611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
40612   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40613
40614   arg1 = (Dali::LinearConstrainer *)jarg1;
40615   {
40616     try {
40617       delete arg1;
40618     } catch (std::out_of_range& e) {
40619       {
40620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40621       };
40622     } catch (std::exception& e) {
40623       {
40624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40625       };
40626     } catch (...) {
40627       {
40628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40629       };
40630     }
40631   }
40632 }
40633
40634
40635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
40636   void * jresult ;
40637   Dali::LinearConstrainer *arg1 = 0 ;
40638   Dali::LinearConstrainer *result = 0 ;
40639
40640   arg1 = (Dali::LinearConstrainer *)jarg1;
40641   if (!arg1) {
40642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40643     return 0;
40644   }
40645   {
40646     try {
40647       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
40648     } catch (std::out_of_range& e) {
40649       {
40650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40651       };
40652     } catch (std::exception& e) {
40653       {
40654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40655       };
40656     } catch (...) {
40657       {
40658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40659       };
40660     }
40661   }
40662   jresult = (void *)result;
40663   return jresult;
40664 }
40665
40666
40667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
40668   void * jresult ;
40669   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40670   Dali::LinearConstrainer *arg2 = 0 ;
40671   Dali::LinearConstrainer *result = 0 ;
40672
40673   arg1 = (Dali::LinearConstrainer *)jarg1;
40674   arg2 = (Dali::LinearConstrainer *)jarg2;
40675   if (!arg2) {
40676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40677     return 0;
40678   }
40679   {
40680     try {
40681       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
40682     } catch (std::out_of_range& e) {
40683       {
40684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40685       };
40686     } catch (std::exception& e) {
40687       {
40688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40689       };
40690     } catch (...) {
40691       {
40692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40693       };
40694     }
40695   }
40696   jresult = (void *)result;
40697   return jresult;
40698 }
40699
40700
40701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40702   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40703   SwigValueWrapper< Dali::Property > arg2 ;
40704   SwigValueWrapper< Dali::Property > arg3 ;
40705   Dali::Vector2 *arg4 = 0 ;
40706   Dali::Vector2 *arg5 = 0 ;
40707   Dali::Property *argp2 ;
40708   Dali::Property *argp3 ;
40709
40710   arg1 = (Dali::LinearConstrainer *)jarg1;
40711   argp2 = (Dali::Property *)jarg2;
40712   if (!argp2) {
40713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40714     return ;
40715   }
40716   arg2 = *argp2;
40717   argp3 = (Dali::Property *)jarg3;
40718   if (!argp3) {
40719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40720     return ;
40721   }
40722   arg3 = *argp3;
40723   arg4 = (Dali::Vector2 *)jarg4;
40724   if (!arg4) {
40725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40726     return ;
40727   }
40728   arg5 = (Dali::Vector2 *)jarg5;
40729   if (!arg5) {
40730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40731     return ;
40732   }
40733   {
40734     try {
40735       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
40736     } catch (std::out_of_range& e) {
40737       {
40738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40739       };
40740     } catch (std::exception& e) {
40741       {
40742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40743       };
40744     } catch (...) {
40745       {
40746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40747       };
40748     }
40749   }
40750 }
40751
40752
40753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40754   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40755   SwigValueWrapper< Dali::Property > arg2 ;
40756   SwigValueWrapper< Dali::Property > arg3 ;
40757   Dali::Vector2 *arg4 = 0 ;
40758   Dali::Property *argp2 ;
40759   Dali::Property *argp3 ;
40760
40761   arg1 = (Dali::LinearConstrainer *)jarg1;
40762   argp2 = (Dali::Property *)jarg2;
40763   if (!argp2) {
40764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40765     return ;
40766   }
40767   arg2 = *argp2;
40768   argp3 = (Dali::Property *)jarg3;
40769   if (!argp3) {
40770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40771     return ;
40772   }
40773   arg3 = *argp3;
40774   arg4 = (Dali::Vector2 *)jarg4;
40775   if (!arg4) {
40776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40777     return ;
40778   }
40779   {
40780     try {
40781       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
40782     } catch (std::out_of_range& e) {
40783       {
40784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40785       };
40786     } catch (std::exception& e) {
40787       {
40788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40789       };
40790     } catch (...) {
40791       {
40792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40793       };
40794     }
40795   }
40796 }
40797
40798
40799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
40800   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40801   Dali::Handle *arg2 = 0 ;
40802
40803   arg1 = (Dali::LinearConstrainer *)jarg1;
40804   arg2 = (Dali::Handle *)jarg2;
40805   if (!arg2) {
40806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
40807     return ;
40808   }
40809   {
40810     try {
40811       (arg1)->Remove(*arg2);
40812     } catch (std::out_of_range& e) {
40813       {
40814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40815       };
40816     } catch (std::exception& e) {
40817       {
40818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40819       };
40820     } catch (...) {
40821       {
40822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40823       };
40824     }
40825   }
40826 }
40827
40828
40829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
40830   int jresult ;
40831   int result;
40832
40833   result = (int)Dali::PathConstrainer::Property::FORWARD;
40834   jresult = (int)result;
40835   return jresult;
40836 }
40837
40838
40839 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
40840   int jresult ;
40841   int result;
40842
40843   result = (int)Dali::PathConstrainer::Property::POINTS;
40844   jresult = (int)result;
40845   return jresult;
40846 }
40847
40848
40849 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
40850   int jresult ;
40851   int result;
40852
40853   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
40854   jresult = (int)result;
40855   return jresult;
40856 }
40857
40858
40859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
40860   void * jresult ;
40861   Dali::PathConstrainer::Property *result = 0 ;
40862
40863   {
40864     try {
40865       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
40866     } catch (std::out_of_range& e) {
40867       {
40868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40869       };
40870     } catch (std::exception& e) {
40871       {
40872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40873       };
40874     } catch (...) {
40875       {
40876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40877       };
40878     }
40879   }
40880   jresult = (void *)result;
40881   return jresult;
40882 }
40883
40884
40885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
40886   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
40887
40888   arg1 = (Dali::PathConstrainer::Property *)jarg1;
40889   {
40890     try {
40891       delete arg1;
40892     } catch (std::out_of_range& e) {
40893       {
40894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40895       };
40896     } catch (std::exception& e) {
40897       {
40898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40899       };
40900     } catch (...) {
40901       {
40902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40903       };
40904     }
40905   }
40906 }
40907
40908
40909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
40910   void * jresult ;
40911   Dali::PathConstrainer result;
40912
40913   {
40914     try {
40915       result = Dali::PathConstrainer::New();
40916     } catch (std::out_of_range& e) {
40917       {
40918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40919       };
40920     } catch (std::exception& e) {
40921       {
40922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40923       };
40924     } catch (...) {
40925       {
40926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40927       };
40928     }
40929   }
40930   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
40931   return jresult;
40932 }
40933
40934
40935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
40936   void * jresult ;
40937   Dali::BaseHandle arg1 ;
40938   Dali::BaseHandle *argp1 ;
40939   Dali::PathConstrainer result;
40940
40941   argp1 = (Dali::BaseHandle *)jarg1;
40942   if (!argp1) {
40943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40944     return 0;
40945   }
40946   arg1 = *argp1;
40947   {
40948     try {
40949       result = Dali::PathConstrainer::DownCast(arg1);
40950     } catch (std::out_of_range& e) {
40951       {
40952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40953       };
40954     } catch (std::exception& e) {
40955       {
40956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40957       };
40958     } catch (...) {
40959       {
40960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40961       };
40962     }
40963   }
40964   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
40965   return jresult;
40966 }
40967
40968
40969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
40970   void * jresult ;
40971   Dali::PathConstrainer *result = 0 ;
40972
40973   {
40974     try {
40975       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
40976     } catch (std::out_of_range& e) {
40977       {
40978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40979       };
40980     } catch (std::exception& e) {
40981       {
40982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40983       };
40984     } catch (...) {
40985       {
40986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40987       };
40988     }
40989   }
40990   jresult = (void *)result;
40991   return jresult;
40992 }
40993
40994
40995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
40996   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40997
40998   arg1 = (Dali::PathConstrainer *)jarg1;
40999   {
41000     try {
41001       delete arg1;
41002     } catch (std::out_of_range& e) {
41003       {
41004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41005       };
41006     } catch (std::exception& e) {
41007       {
41008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41009       };
41010     } catch (...) {
41011       {
41012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41013       };
41014     }
41015   }
41016 }
41017
41018
41019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
41020   void * jresult ;
41021   Dali::PathConstrainer *arg1 = 0 ;
41022   Dali::PathConstrainer *result = 0 ;
41023
41024   arg1 = (Dali::PathConstrainer *)jarg1;
41025   if (!arg1) {
41026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
41027     return 0;
41028   }
41029   {
41030     try {
41031       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
41032     } catch (std::out_of_range& e) {
41033       {
41034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41035       };
41036     } catch (std::exception& e) {
41037       {
41038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41039       };
41040     } catch (...) {
41041       {
41042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41043       };
41044     }
41045   }
41046   jresult = (void *)result;
41047   return jresult;
41048 }
41049
41050
41051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
41052   void * jresult ;
41053   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41054   Dali::PathConstrainer *arg2 = 0 ;
41055   Dali::PathConstrainer *result = 0 ;
41056
41057   arg1 = (Dali::PathConstrainer *)jarg1;
41058   arg2 = (Dali::PathConstrainer *)jarg2;
41059   if (!arg2) {
41060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
41061     return 0;
41062   }
41063   {
41064     try {
41065       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
41066     } catch (std::out_of_range& e) {
41067       {
41068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41069       };
41070     } catch (std::exception& e) {
41071       {
41072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41073       };
41074     } catch (...) {
41075       {
41076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41077       };
41078     }
41079   }
41080   jresult = (void *)result;
41081   return jresult;
41082 }
41083
41084
41085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
41086   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41087   SwigValueWrapper< Dali::Property > arg2 ;
41088   SwigValueWrapper< Dali::Property > arg3 ;
41089   Dali::Vector2 *arg4 = 0 ;
41090   Dali::Vector2 *arg5 = 0 ;
41091   Dali::Property *argp2 ;
41092   Dali::Property *argp3 ;
41093
41094   arg1 = (Dali::PathConstrainer *)jarg1;
41095   argp2 = (Dali::Property *)jarg2;
41096   if (!argp2) {
41097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41098     return ;
41099   }
41100   arg2 = *argp2;
41101   argp3 = (Dali::Property *)jarg3;
41102   if (!argp3) {
41103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41104     return ;
41105   }
41106   arg3 = *argp3;
41107   arg4 = (Dali::Vector2 *)jarg4;
41108   if (!arg4) {
41109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41110     return ;
41111   }
41112   arg5 = (Dali::Vector2 *)jarg5;
41113   if (!arg5) {
41114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41115     return ;
41116   }
41117   {
41118     try {
41119       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
41120     } catch (std::out_of_range& e) {
41121       {
41122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41123       };
41124     } catch (std::exception& e) {
41125       {
41126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41127       };
41128     } catch (...) {
41129       {
41130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41131       };
41132     }
41133   }
41134 }
41135
41136
41137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
41138   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41139   SwigValueWrapper< Dali::Property > arg2 ;
41140   SwigValueWrapper< Dali::Property > arg3 ;
41141   Dali::Vector2 *arg4 = 0 ;
41142   Dali::Property *argp2 ;
41143   Dali::Property *argp3 ;
41144
41145   arg1 = (Dali::PathConstrainer *)jarg1;
41146   argp2 = (Dali::Property *)jarg2;
41147   if (!argp2) {
41148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41149     return ;
41150   }
41151   arg2 = *argp2;
41152   argp3 = (Dali::Property *)jarg3;
41153   if (!argp3) {
41154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41155     return ;
41156   }
41157   arg3 = *argp3;
41158   arg4 = (Dali::Vector2 *)jarg4;
41159   if (!arg4) {
41160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41161     return ;
41162   }
41163   {
41164     try {
41165       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
41166     } catch (std::out_of_range& e) {
41167       {
41168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41169       };
41170     } catch (std::exception& e) {
41171       {
41172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41173       };
41174     } catch (...) {
41175       {
41176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41177       };
41178     }
41179   }
41180 }
41181
41182
41183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
41184   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41185   Dali::Handle *arg2 = 0 ;
41186
41187   arg1 = (Dali::PathConstrainer *)jarg1;
41188   arg2 = (Dali::Handle *)jarg2;
41189   if (!arg2) {
41190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
41191     return ;
41192   }
41193   {
41194     try {
41195       (arg1)->Remove(*arg2);
41196     } catch (std::out_of_range& e) {
41197       {
41198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41199       };
41200     } catch (std::exception& e) {
41201       {
41202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41203       };
41204     } catch (...) {
41205       {
41206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41207       };
41208     }
41209   }
41210 }
41211
41212
41213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
41214   int jresult ;
41215   Dali::FittingMode::Type result;
41216
41217   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
41218   jresult = (int)result;
41219   return jresult;
41220 }
41221
41222
41223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
41224   int jresult ;
41225   Dali::SamplingMode::Type result;
41226
41227   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
41228   jresult = (int)result;
41229   return jresult;
41230 }
41231
41232
41233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
41234   void * jresult ;
41235   Dali::BufferImage *result = 0 ;
41236
41237   {
41238     try {
41239       result = (Dali::BufferImage *)new Dali::BufferImage();
41240     } catch (std::out_of_range& e) {
41241       {
41242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41243       };
41244     } catch (std::exception& e) {
41245       {
41246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41247       };
41248     } catch (...) {
41249       {
41250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41251       };
41252     }
41253   }
41254   jresult = (void *)result;
41255   return jresult;
41256 }
41257
41258
41259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
41260   void * jresult ;
41261   unsigned int arg1 ;
41262   unsigned int arg2 ;
41263   Dali::Pixel::Format arg3 ;
41264   Dali::BufferImage result;
41265
41266   arg1 = (unsigned int)jarg1;
41267   arg2 = (unsigned int)jarg2;
41268   arg3 = (Dali::Pixel::Format)jarg3;
41269   {
41270     try {
41271       result = Dali::BufferImage::New(arg1,arg2,arg3);
41272     } catch (std::out_of_range& e) {
41273       {
41274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41275       };
41276     } catch (std::exception& e) {
41277       {
41278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41279       };
41280     } catch (...) {
41281       {
41282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41283       };
41284     }
41285   }
41286   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41287   return jresult;
41288 }
41289
41290
41291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
41292   void * jresult ;
41293   unsigned int arg1 ;
41294   unsigned int arg2 ;
41295   Dali::BufferImage result;
41296
41297   arg1 = (unsigned int)jarg1;
41298   arg2 = (unsigned int)jarg2;
41299   {
41300     try {
41301       result = Dali::BufferImage::New(arg1,arg2);
41302     } catch (std::out_of_range& e) {
41303       {
41304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41305       };
41306     } catch (std::exception& e) {
41307       {
41308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41309       };
41310     } catch (...) {
41311       {
41312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41313       };
41314     }
41315   }
41316   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41317   return jresult;
41318 }
41319
41320
41321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
41322   void * jresult ;
41323   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41324   unsigned int arg2 ;
41325   unsigned int arg3 ;
41326   Dali::Pixel::Format arg4 ;
41327   unsigned int arg5 ;
41328   Dali::BufferImage result;
41329
41330   arg1 = jarg1;
41331   arg2 = (unsigned int)jarg2;
41332   arg3 = (unsigned int)jarg3;
41333   arg4 = (Dali::Pixel::Format)jarg4;
41334   arg5 = (unsigned int)jarg5;
41335   {
41336     try {
41337       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
41338     } catch (std::out_of_range& e) {
41339       {
41340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41341       };
41342     } catch (std::exception& e) {
41343       {
41344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41345       };
41346     } catch (...) {
41347       {
41348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41349       };
41350     }
41351   }
41352   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41353
41354
41355   return jresult;
41356 }
41357
41358
41359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
41360   void * jresult ;
41361   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41362   unsigned int arg2 ;
41363   unsigned int arg3 ;
41364   Dali::Pixel::Format arg4 ;
41365   Dali::BufferImage result;
41366
41367   arg1 = jarg1;
41368   arg2 = (unsigned int)jarg2;
41369   arg3 = (unsigned int)jarg3;
41370   arg4 = (Dali::Pixel::Format)jarg4;
41371   {
41372     try {
41373       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
41374     } catch (std::out_of_range& e) {
41375       {
41376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41377       };
41378     } catch (std::exception& e) {
41379       {
41380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41381       };
41382     } catch (...) {
41383       {
41384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41385       };
41386     }
41387   }
41388   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41389
41390
41391   return jresult;
41392 }
41393
41394
41395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
41396   void * jresult ;
41397   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41398   unsigned int arg2 ;
41399   unsigned int arg3 ;
41400   Dali::BufferImage result;
41401
41402   arg1 = jarg1;
41403   arg2 = (unsigned int)jarg2;
41404   arg3 = (unsigned int)jarg3;
41405   {
41406     try {
41407       result = Dali::BufferImage::New(arg1,arg2,arg3);
41408     } catch (std::out_of_range& e) {
41409       {
41410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41411       };
41412     } catch (std::exception& e) {
41413       {
41414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41415       };
41416     } catch (...) {
41417       {
41418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41419       };
41420     }
41421   }
41422   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41423
41424
41425   return jresult;
41426 }
41427
41428
41429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
41430   void * jresult ;
41431   Dali::BaseHandle arg1 ;
41432   Dali::BaseHandle *argp1 ;
41433   Dali::BufferImage result;
41434
41435   argp1 = (Dali::BaseHandle *)jarg1;
41436   if (!argp1) {
41437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41438     return 0;
41439   }
41440   arg1 = *argp1;
41441   {
41442     try {
41443       result = Dali::BufferImage::DownCast(arg1);
41444     } catch (std::out_of_range& e) {
41445       {
41446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41447       };
41448     } catch (std::exception& e) {
41449       {
41450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41451       };
41452     } catch (...) {
41453       {
41454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41455       };
41456     }
41457   }
41458   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41459   return jresult;
41460 }
41461
41462
41463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
41464   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41465
41466   arg1 = (Dali::BufferImage *)jarg1;
41467   {
41468     try {
41469       delete arg1;
41470     } catch (std::out_of_range& e) {
41471       {
41472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41473       };
41474     } catch (std::exception& e) {
41475       {
41476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41477       };
41478     } catch (...) {
41479       {
41480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41481       };
41482     }
41483   }
41484 }
41485
41486
41487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
41488   void * jresult ;
41489   Dali::BufferImage *arg1 = 0 ;
41490   Dali::BufferImage *result = 0 ;
41491
41492   arg1 = (Dali::BufferImage *)jarg1;
41493   if (!arg1) {
41494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
41495     return 0;
41496   }
41497   {
41498     try {
41499       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
41500     } catch (std::out_of_range& e) {
41501       {
41502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41503       };
41504     } catch (std::exception& e) {
41505       {
41506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41507       };
41508     } catch (...) {
41509       {
41510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41511       };
41512     }
41513   }
41514   jresult = (void *)result;
41515   return jresult;
41516 }
41517
41518
41519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
41520   void * jresult ;
41521   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41522   Dali::BufferImage *arg2 = 0 ;
41523   Dali::BufferImage *result = 0 ;
41524
41525   arg1 = (Dali::BufferImage *)jarg1;
41526   arg2 = (Dali::BufferImage *)jarg2;
41527   if (!arg2) {
41528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
41529     return 0;
41530   }
41531   {
41532     try {
41533       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
41534     } catch (std::out_of_range& e) {
41535       {
41536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41537       };
41538     } catch (std::exception& e) {
41539       {
41540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41541       };
41542     } catch (...) {
41543       {
41544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41545       };
41546     }
41547   }
41548   jresult = (void *)result;
41549   return jresult;
41550 }
41551
41552
41553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
41554   void * jresult ;
41555   Dali::BufferImage result;
41556
41557   {
41558     try {
41559       result = Dali::BufferImage::WHITE();
41560     } catch (std::out_of_range& e) {
41561       {
41562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41563       };
41564     } catch (std::exception& e) {
41565       {
41566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41567       };
41568     } catch (...) {
41569       {
41570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41571       };
41572     }
41573   }
41574   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41575   return jresult;
41576 }
41577
41578
41579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
41580   void * jresult ;
41581   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41582   Dali::PixelBuffer *result = 0 ;
41583
41584   arg1 = (Dali::BufferImage *)jarg1;
41585   {
41586     try {
41587       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
41588     } catch (std::out_of_range& e) {
41589       {
41590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41591       };
41592     } catch (std::exception& e) {
41593       {
41594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41595       };
41596     } catch (...) {
41597       {
41598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41599       };
41600     }
41601   }
41602   jresult = (void *)result;
41603   return jresult;
41604 }
41605
41606
41607 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
41608   unsigned int jresult ;
41609   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41610   unsigned int result;
41611
41612   arg1 = (Dali::BufferImage *)jarg1;
41613   {
41614     try {
41615       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
41616     } catch (std::out_of_range& e) {
41617       {
41618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41619       };
41620     } catch (std::exception& e) {
41621       {
41622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41623       };
41624     } catch (...) {
41625       {
41626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41627       };
41628     }
41629   }
41630   jresult = result;
41631   return jresult;
41632 }
41633
41634
41635 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
41636   unsigned int jresult ;
41637   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41638   unsigned int result;
41639
41640   arg1 = (Dali::BufferImage *)jarg1;
41641   {
41642     try {
41643       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
41644     } catch (std::out_of_range& e) {
41645       {
41646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41647       };
41648     } catch (std::exception& e) {
41649       {
41650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41651       };
41652     } catch (...) {
41653       {
41654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41655       };
41656     }
41657   }
41658   jresult = result;
41659   return jresult;
41660 }
41661
41662
41663 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
41664   int jresult ;
41665   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41666   Dali::Pixel::Format result;
41667
41668   arg1 = (Dali::BufferImage *)jarg1;
41669   {
41670     try {
41671       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
41672     } catch (std::out_of_range& e) {
41673       {
41674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41675       };
41676     } catch (std::exception& e) {
41677       {
41678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41679       };
41680     } catch (...) {
41681       {
41682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41683       };
41684     }
41685   }
41686   jresult = (int)result;
41687   return jresult;
41688 }
41689
41690
41691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
41692   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41693
41694   arg1 = (Dali::BufferImage *)jarg1;
41695   {
41696     try {
41697       (arg1)->Update();
41698     } catch (std::out_of_range& e) {
41699       {
41700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41701       };
41702     } catch (std::exception& e) {
41703       {
41704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41705       };
41706     } catch (...) {
41707       {
41708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41709       };
41710     }
41711   }
41712 }
41713
41714
41715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
41716   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41717   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
41718   Dali::RectArea *argp2 ;
41719
41720   arg1 = (Dali::BufferImage *)jarg1;
41721   argp2 = (Dali::RectArea *)jarg2;
41722   if (!argp2) {
41723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
41724     return ;
41725   }
41726   arg2 = *argp2;
41727   {
41728     try {
41729       (arg1)->Update(arg2);
41730     } catch (std::out_of_range& e) {
41731       {
41732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41733       };
41734     } catch (std::exception& e) {
41735       {
41736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41737       };
41738     } catch (...) {
41739       {
41740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41741       };
41742     }
41743   }
41744 }
41745
41746
41747 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
41748   unsigned int jresult ;
41749   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41750   bool result;
41751
41752   arg1 = (Dali::BufferImage *)jarg1;
41753   {
41754     try {
41755       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
41756     } catch (std::out_of_range& e) {
41757       {
41758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41759       };
41760     } catch (std::exception& e) {
41761       {
41762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41763       };
41764     } catch (...) {
41765       {
41766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41767       };
41768     }
41769   }
41770   jresult = result;
41771   return jresult;
41772 }
41773
41774
41775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
41776   void * jresult ;
41777   Dali::EncodedBufferImage *result = 0 ;
41778
41779   {
41780     try {
41781       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
41782     } catch (std::out_of_range& e) {
41783       {
41784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41785       };
41786     } catch (std::exception& e) {
41787       {
41788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41789       };
41790     } catch (...) {
41791       {
41792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41793       };
41794     }
41795   }
41796   jresult = (void *)result;
41797   return jresult;
41798 }
41799
41800
41801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
41802   void * jresult ;
41803   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41804   std::size_t arg2 ;
41805   Dali::EncodedBufferImage result;
41806
41807   arg1 = (uint8_t *)jarg1;
41808   arg2 = (std::size_t)jarg2;
41809   {
41810     try {
41811       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
41812     } catch (std::out_of_range& e) {
41813       {
41814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41815       };
41816     } catch (std::exception& e) {
41817       {
41818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41819       };
41820     } catch (...) {
41821       {
41822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41823       };
41824     }
41825   }
41826   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41827   return jresult;
41828 }
41829
41830
41831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
41832   void * jresult ;
41833   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41834   std::size_t arg2 ;
41835   Dali::ImageDimensions arg3 ;
41836   Dali::FittingMode::Type arg4 ;
41837   Dali::SamplingMode::Type arg5 ;
41838   bool arg6 ;
41839   Dali::ImageDimensions *argp3 ;
41840   Dali::EncodedBufferImage result;
41841
41842   arg1 = (uint8_t *)jarg1;
41843   arg2 = (std::size_t)jarg2;
41844   argp3 = (Dali::ImageDimensions *)jarg3;
41845   if (!argp3) {
41846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41847     return 0;
41848   }
41849   arg3 = *argp3;
41850   arg4 = (Dali::FittingMode::Type)jarg4;
41851   arg5 = (Dali::SamplingMode::Type)jarg5;
41852   arg6 = jarg6 ? true : false;
41853   {
41854     try {
41855       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
41856     } catch (std::out_of_range& e) {
41857       {
41858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41859       };
41860     } catch (std::exception& e) {
41861       {
41862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41863       };
41864     } catch (...) {
41865       {
41866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41867       };
41868     }
41869   }
41870   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41871   return jresult;
41872 }
41873
41874
41875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
41876   void * jresult ;
41877   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41878   std::size_t arg2 ;
41879   Dali::ImageDimensions arg3 ;
41880   Dali::FittingMode::Type arg4 ;
41881   Dali::SamplingMode::Type arg5 ;
41882   Dali::ImageDimensions *argp3 ;
41883   Dali::EncodedBufferImage result;
41884
41885   arg1 = (uint8_t *)jarg1;
41886   arg2 = (std::size_t)jarg2;
41887   argp3 = (Dali::ImageDimensions *)jarg3;
41888   if (!argp3) {
41889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41890     return 0;
41891   }
41892   arg3 = *argp3;
41893   arg4 = (Dali::FittingMode::Type)jarg4;
41894   arg5 = (Dali::SamplingMode::Type)jarg5;
41895   {
41896     try {
41897       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
41898     } catch (std::out_of_range& e) {
41899       {
41900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41901       };
41902     } catch (std::exception& e) {
41903       {
41904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41905       };
41906     } catch (...) {
41907       {
41908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41909       };
41910     }
41911   }
41912   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41913   return jresult;
41914 }
41915
41916
41917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
41918   void * jresult ;
41919   Dali::BaseHandle arg1 ;
41920   Dali::BaseHandle *argp1 ;
41921   Dali::EncodedBufferImage result;
41922
41923   argp1 = (Dali::BaseHandle *)jarg1;
41924   if (!argp1) {
41925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41926     return 0;
41927   }
41928   arg1 = *argp1;
41929   {
41930     try {
41931       result = Dali::EncodedBufferImage::DownCast(arg1);
41932     } catch (std::out_of_range& e) {
41933       {
41934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41935       };
41936     } catch (std::exception& e) {
41937       {
41938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41939       };
41940     } catch (...) {
41941       {
41942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41943       };
41944     }
41945   }
41946   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41947   return jresult;
41948 }
41949
41950
41951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
41952   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
41953
41954   arg1 = (Dali::EncodedBufferImage *)jarg1;
41955   {
41956     try {
41957       delete arg1;
41958     } catch (std::out_of_range& e) {
41959       {
41960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41961       };
41962     } catch (std::exception& e) {
41963       {
41964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41965       };
41966     } catch (...) {
41967       {
41968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41969       };
41970     }
41971   }
41972 }
41973
41974
41975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
41976   void * jresult ;
41977   Dali::EncodedBufferImage *arg1 = 0 ;
41978   Dali::EncodedBufferImage *result = 0 ;
41979
41980   arg1 = (Dali::EncodedBufferImage *)jarg1;
41981   if (!arg1) {
41982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
41983     return 0;
41984   }
41985   {
41986     try {
41987       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
41988     } catch (std::out_of_range& e) {
41989       {
41990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41991       };
41992     } catch (std::exception& e) {
41993       {
41994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41995       };
41996     } catch (...) {
41997       {
41998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41999       };
42000     }
42001   }
42002   jresult = (void *)result;
42003   return jresult;
42004 }
42005
42006
42007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
42008   void * jresult ;
42009   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
42010   Dali::EncodedBufferImage *arg2 = 0 ;
42011   Dali::EncodedBufferImage *result = 0 ;
42012
42013   arg1 = (Dali::EncodedBufferImage *)jarg1;
42014   arg2 = (Dali::EncodedBufferImage *)jarg2;
42015   if (!arg2) {
42016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
42017     return 0;
42018   }
42019   {
42020     try {
42021       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
42022     } catch (std::out_of_range& e) {
42023       {
42024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42025       };
42026     } catch (std::exception& e) {
42027       {
42028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42029       };
42030     } catch (...) {
42031       {
42032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42033       };
42034     }
42035   }
42036   jresult = (void *)result;
42037   return jresult;
42038 }
42039
42040
42041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
42042   void * jresult ;
42043   Dali::NativeImage *result = 0 ;
42044
42045   {
42046     try {
42047       result = (Dali::NativeImage *)new Dali::NativeImage();
42048     } catch (std::out_of_range& e) {
42049       {
42050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42051       };
42052     } catch (std::exception& e) {
42053       {
42054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42055       };
42056     } catch (...) {
42057       {
42058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42059       };
42060     }
42061   }
42062   jresult = (void *)result;
42063   return jresult;
42064 }
42065
42066
42067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
42068   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42069
42070   arg1 = (Dali::NativeImage *)jarg1;
42071   {
42072     try {
42073       delete arg1;
42074     } catch (std::out_of_range& e) {
42075       {
42076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42077       };
42078     } catch (std::exception& e) {
42079       {
42080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42081       };
42082     } catch (...) {
42083       {
42084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42085       };
42086     }
42087   }
42088 }
42089
42090
42091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
42092   void * jresult ;
42093   Dali::NativeImage *arg1 = 0 ;
42094   Dali::NativeImage *result = 0 ;
42095
42096   arg1 = (Dali::NativeImage *)jarg1;
42097   if (!arg1) {
42098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
42099     return 0;
42100   }
42101   {
42102     try {
42103       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
42104     } catch (std::out_of_range& e) {
42105       {
42106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42107       };
42108     } catch (std::exception& e) {
42109       {
42110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42111       };
42112     } catch (...) {
42113       {
42114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42115       };
42116     }
42117   }
42118   jresult = (void *)result;
42119   return jresult;
42120 }
42121
42122
42123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
42124   void * jresult ;
42125   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42126   Dali::NativeImage *arg2 = 0 ;
42127   Dali::NativeImage *result = 0 ;
42128
42129   arg1 = (Dali::NativeImage *)jarg1;
42130   arg2 = (Dali::NativeImage *)jarg2;
42131   if (!arg2) {
42132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
42133     return 0;
42134   }
42135   {
42136     try {
42137       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
42138     } catch (std::out_of_range& e) {
42139       {
42140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42141       };
42142     } catch (std::exception& e) {
42143       {
42144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42145       };
42146     } catch (...) {
42147       {
42148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42149       };
42150     }
42151   }
42152   jresult = (void *)result;
42153   return jresult;
42154 }
42155
42156
42157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
42158   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42159
42160   arg1 = (Dali::NativeImage *)jarg1;
42161   {
42162     try {
42163       (arg1)->CreateGlTexture();
42164     } catch (std::out_of_range& e) {
42165       {
42166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42167       };
42168     } catch (std::exception& e) {
42169       {
42170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42171       };
42172     } catch (...) {
42173       {
42174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42175       };
42176     }
42177   }
42178 }
42179
42180
42181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
42182   void * jresult ;
42183   NativeImageInterface *arg1 = 0 ;
42184   Dali::NativeImage result;
42185
42186   arg1 = (NativeImageInterface *)jarg1;
42187   if (!arg1) {
42188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
42189     return 0;
42190   }
42191   {
42192     try {
42193       result = Dali::NativeImage::New(*arg1);
42194     } catch (std::out_of_range& e) {
42195       {
42196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42197       };
42198     } catch (std::exception& e) {
42199       {
42200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42201       };
42202     } catch (...) {
42203       {
42204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42205       };
42206     }
42207   }
42208   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
42209   return jresult;
42210 }
42211
42212
42213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
42214   void * jresult ;
42215   Dali::BaseHandle arg1 ;
42216   Dali::BaseHandle *argp1 ;
42217   Dali::NativeImage result;
42218
42219   argp1 = (Dali::BaseHandle *)jarg1;
42220   if (!argp1) {
42221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42222     return 0;
42223   }
42224   arg1 = *argp1;
42225   {
42226     try {
42227       result = Dali::NativeImage::DownCast(arg1);
42228     } catch (std::out_of_range& e) {
42229       {
42230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42231       };
42232     } catch (std::exception& e) {
42233       {
42234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42235       };
42236     } catch (...) {
42237       {
42238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42239       };
42240     }
42241   }
42242   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
42243   return jresult;
42244 }
42245
42246
42247 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
42248   char * jresult ;
42249   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42250   char *result = 0 ;
42251
42252   arg1 = (Dali::NativeImage *)jarg1;
42253   {
42254     try {
42255       result = (char *)(arg1)->GetCustomFragmentPreFix();
42256     } catch (std::out_of_range& e) {
42257       {
42258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42259       };
42260     } catch (std::exception& e) {
42261       {
42262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42263       };
42264     } catch (...) {
42265       {
42266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42267       };
42268     }
42269   }
42270   jresult = SWIG_csharp_string_callback((const char *)result);
42271   return jresult;
42272 }
42273
42274
42275 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
42276   char * jresult ;
42277   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42278   char *result = 0 ;
42279
42280   arg1 = (Dali::NativeImage *)jarg1;
42281   {
42282     try {
42283       result = (char *)(arg1)->GetCustomSamplerTypename();
42284     } catch (std::out_of_range& e) {
42285       {
42286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42287       };
42288     } catch (std::exception& e) {
42289       {
42290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42291       };
42292     } catch (...) {
42293       {
42294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42295       };
42296     }
42297   }
42298   jresult = SWIG_csharp_string_callback((const char *)result);
42299   return jresult;
42300 }
42301
42302
42303 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
42304   unsigned int jresult ;
42305   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42306   bool result;
42307
42308   arg1 = (Dali::NativeImageInterface *)jarg1;
42309   {
42310     try {
42311       result = (bool)(arg1)->GlExtensionCreate();
42312     } catch (std::out_of_range& e) {
42313       {
42314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42315       };
42316     } catch (std::exception& e) {
42317       {
42318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42319       };
42320     } catch (...) {
42321       {
42322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42323       };
42324     }
42325   }
42326   jresult = result;
42327   return jresult;
42328 }
42329
42330
42331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
42332   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42333
42334   arg1 = (Dali::NativeImageInterface *)jarg1;
42335   {
42336     try {
42337       (arg1)->GlExtensionDestroy();
42338     } catch (std::out_of_range& e) {
42339       {
42340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42341       };
42342     } catch (std::exception& e) {
42343       {
42344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42345       };
42346     } catch (...) {
42347       {
42348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42349       };
42350     }
42351   }
42352 }
42353
42354
42355 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
42356   unsigned int jresult ;
42357   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42358   unsigned int result;
42359
42360   arg1 = (Dali::NativeImageInterface *)jarg1;
42361   {
42362     try {
42363       result = (unsigned int)(arg1)->TargetTexture();
42364     } catch (std::out_of_range& e) {
42365       {
42366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42367       };
42368     } catch (std::exception& e) {
42369       {
42370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42371       };
42372     } catch (...) {
42373       {
42374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42375       };
42376     }
42377   }
42378   jresult = result;
42379   return jresult;
42380 }
42381
42382
42383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
42384   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42385
42386   arg1 = (Dali::NativeImageInterface *)jarg1;
42387   {
42388     try {
42389       (arg1)->PrepareTexture();
42390     } catch (std::out_of_range& e) {
42391       {
42392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42393       };
42394     } catch (std::exception& e) {
42395       {
42396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42397       };
42398     } catch (...) {
42399       {
42400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42401       };
42402     }
42403   }
42404 }
42405
42406
42407 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
42408   unsigned int jresult ;
42409   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42410   unsigned int result;
42411
42412   arg1 = (Dali::NativeImageInterface *)jarg1;
42413   {
42414     try {
42415       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
42416     } catch (std::out_of_range& e) {
42417       {
42418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42419       };
42420     } catch (std::exception& e) {
42421       {
42422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42423       };
42424     } catch (...) {
42425       {
42426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42427       };
42428     }
42429   }
42430   jresult = result;
42431   return jresult;
42432 }
42433
42434
42435 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
42436   unsigned int jresult ;
42437   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42438   unsigned int result;
42439
42440   arg1 = (Dali::NativeImageInterface *)jarg1;
42441   {
42442     try {
42443       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
42444     } catch (std::out_of_range& e) {
42445       {
42446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42447       };
42448     } catch (std::exception& e) {
42449       {
42450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42451       };
42452     } catch (...) {
42453       {
42454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42455       };
42456     }
42457   }
42458   jresult = result;
42459   return jresult;
42460 }
42461
42462
42463 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
42464   unsigned int jresult ;
42465   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42466   bool result;
42467
42468   arg1 = (Dali::NativeImageInterface *)jarg1;
42469   {
42470     try {
42471       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
42472     } catch (std::out_of_range& e) {
42473       {
42474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42475       };
42476     } catch (std::exception& e) {
42477       {
42478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42479       };
42480     } catch (...) {
42481       {
42482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42483       };
42484     }
42485   }
42486   jresult = result;
42487   return jresult;
42488 }
42489
42490
42491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
42492   void * jresult ;
42493   std::string *arg1 = 0 ;
42494   Dali::ImageDimensions result;
42495
42496   if (!jarg1) {
42497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42498     return 0;
42499   }
42500   std::string arg1_str(jarg1);
42501   arg1 = &arg1_str;
42502   {
42503     try {
42504       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
42505     } catch (std::out_of_range& e) {
42506       {
42507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42508       };
42509     } catch (std::exception& e) {
42510       {
42511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42512       };
42513     } catch (...) {
42514       {
42515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42516       };
42517     }
42518   }
42519   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
42520
42521   //argout typemap for const std::string&
42522
42523   return jresult;
42524 }
42525
42526
42527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
42528   void * jresult ;
42529   Dali::ResourceImage *result = 0 ;
42530
42531   {
42532     try {
42533       result = (Dali::ResourceImage *)new Dali::ResourceImage();
42534     } catch (std::out_of_range& e) {
42535       {
42536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42537       };
42538     } catch (std::exception& e) {
42539       {
42540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42541       };
42542     } catch (...) {
42543       {
42544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42545       };
42546     }
42547   }
42548   jresult = (void *)result;
42549   return jresult;
42550 }
42551
42552
42553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
42554   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42555
42556   arg1 = (Dali::ResourceImage *)jarg1;
42557   {
42558     try {
42559       delete arg1;
42560     } catch (std::out_of_range& e) {
42561       {
42562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42563       };
42564     } catch (std::exception& e) {
42565       {
42566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42567       };
42568     } catch (...) {
42569       {
42570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42571       };
42572     }
42573   }
42574 }
42575
42576
42577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
42578   void * jresult ;
42579   Dali::ResourceImage *arg1 = 0 ;
42580   Dali::ResourceImage *result = 0 ;
42581
42582   arg1 = (Dali::ResourceImage *)jarg1;
42583   if (!arg1) {
42584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42585     return 0;
42586   }
42587   {
42588     try {
42589       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
42590     } catch (std::out_of_range& e) {
42591       {
42592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42593       };
42594     } catch (std::exception& e) {
42595       {
42596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42597       };
42598     } catch (...) {
42599       {
42600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42601       };
42602     }
42603   }
42604   jresult = (void *)result;
42605   return jresult;
42606 }
42607
42608
42609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
42610   void * jresult ;
42611   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42612   Dali::ResourceImage *arg2 = 0 ;
42613   Dali::ResourceImage *result = 0 ;
42614
42615   arg1 = (Dali::ResourceImage *)jarg1;
42616   arg2 = (Dali::ResourceImage *)jarg2;
42617   if (!arg2) {
42618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42619     return 0;
42620   }
42621   {
42622     try {
42623       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
42624     } catch (std::out_of_range& e) {
42625       {
42626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42627       };
42628     } catch (std::exception& e) {
42629       {
42630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42631       };
42632     } catch (...) {
42633       {
42634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42635       };
42636     }
42637   }
42638   jresult = (void *)result;
42639   return jresult;
42640 }
42641
42642
42643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
42644   void * jresult ;
42645   std::string *arg1 = 0 ;
42646   bool arg2 ;
42647   Dali::ResourceImage result;
42648
42649   if (!jarg1) {
42650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42651     return 0;
42652   }
42653   std::string arg1_str(jarg1);
42654   arg1 = &arg1_str;
42655   arg2 = jarg2 ? true : false;
42656   {
42657     try {
42658       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42659     } catch (std::out_of_range& e) {
42660       {
42661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42662       };
42663     } catch (std::exception& e) {
42664       {
42665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42666       };
42667     } catch (...) {
42668       {
42669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42670       };
42671     }
42672   }
42673   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42674
42675   //argout typemap for const std::string&
42676
42677   return jresult;
42678 }
42679
42680
42681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
42682   void * jresult ;
42683   std::string *arg1 = 0 ;
42684   Dali::ResourceImage result;
42685
42686   if (!jarg1) {
42687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42688     return 0;
42689   }
42690   std::string arg1_str(jarg1);
42691   arg1 = &arg1_str;
42692   {
42693     try {
42694       result = Dali::ResourceImage::New((std::string const &)*arg1);
42695     } catch (std::out_of_range& e) {
42696       {
42697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42698       };
42699     } catch (std::exception& e) {
42700       {
42701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42702       };
42703     } catch (...) {
42704       {
42705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42706       };
42707     }
42708   }
42709   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42710
42711   //argout typemap for const std::string&
42712
42713   return jresult;
42714 }
42715
42716
42717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
42718   void * jresult ;
42719   std::string *arg1 = 0 ;
42720   Dali::ImageDimensions arg2 ;
42721   Dali::FittingMode::Type arg3 ;
42722   Dali::SamplingMode::Type arg4 ;
42723   bool arg5 ;
42724   Dali::ImageDimensions *argp2 ;
42725   Dali::ResourceImage result;
42726
42727   if (!jarg1) {
42728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42729     return 0;
42730   }
42731   std::string arg1_str(jarg1);
42732   arg1 = &arg1_str;
42733   argp2 = (Dali::ImageDimensions *)jarg2;
42734   if (!argp2) {
42735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42736     return 0;
42737   }
42738   arg2 = *argp2;
42739   arg3 = (Dali::FittingMode::Type)jarg3;
42740   arg4 = (Dali::SamplingMode::Type)jarg4;
42741   arg5 = jarg5 ? true : false;
42742   {
42743     try {
42744       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
42745     } catch (std::out_of_range& e) {
42746       {
42747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42748       };
42749     } catch (std::exception& e) {
42750       {
42751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42752       };
42753     } catch (...) {
42754       {
42755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42756       };
42757     }
42758   }
42759   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42760
42761   //argout typemap for const std::string&
42762
42763   return jresult;
42764 }
42765
42766
42767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
42768   void * jresult ;
42769   std::string *arg1 = 0 ;
42770   Dali::ImageDimensions arg2 ;
42771   Dali::FittingMode::Type arg3 ;
42772   Dali::SamplingMode::Type arg4 ;
42773   Dali::ImageDimensions *argp2 ;
42774   Dali::ResourceImage result;
42775
42776   if (!jarg1) {
42777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42778     return 0;
42779   }
42780   std::string arg1_str(jarg1);
42781   arg1 = &arg1_str;
42782   argp2 = (Dali::ImageDimensions *)jarg2;
42783   if (!argp2) {
42784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42785     return 0;
42786   }
42787   arg2 = *argp2;
42788   arg3 = (Dali::FittingMode::Type)jarg3;
42789   arg4 = (Dali::SamplingMode::Type)jarg4;
42790   {
42791     try {
42792       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
42793     } catch (std::out_of_range& e) {
42794       {
42795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42796       };
42797     } catch (std::exception& e) {
42798       {
42799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42800       };
42801     } catch (...) {
42802       {
42803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42804       };
42805     }
42806   }
42807   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42808
42809   //argout typemap for const std::string&
42810
42811   return jresult;
42812 }
42813
42814
42815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
42816   void * jresult ;
42817   std::string *arg1 = 0 ;
42818   Dali::ImageDimensions arg2 ;
42819   Dali::FittingMode::Type arg3 ;
42820   Dali::ImageDimensions *argp2 ;
42821   Dali::ResourceImage result;
42822
42823   if (!jarg1) {
42824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42825     return 0;
42826   }
42827   std::string arg1_str(jarg1);
42828   arg1 = &arg1_str;
42829   argp2 = (Dali::ImageDimensions *)jarg2;
42830   if (!argp2) {
42831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42832     return 0;
42833   }
42834   arg2 = *argp2;
42835   arg3 = (Dali::FittingMode::Type)jarg3;
42836   {
42837     try {
42838       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
42839     } catch (std::out_of_range& e) {
42840       {
42841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42842       };
42843     } catch (std::exception& e) {
42844       {
42845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42846       };
42847     } catch (...) {
42848       {
42849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42850       };
42851     }
42852   }
42853   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42854
42855   //argout typemap for const std::string&
42856
42857   return jresult;
42858 }
42859
42860
42861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
42862   void * jresult ;
42863   std::string *arg1 = 0 ;
42864   Dali::ImageDimensions arg2 ;
42865   Dali::ImageDimensions *argp2 ;
42866   Dali::ResourceImage result;
42867
42868   if (!jarg1) {
42869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42870     return 0;
42871   }
42872   std::string arg1_str(jarg1);
42873   arg1 = &arg1_str;
42874   argp2 = (Dali::ImageDimensions *)jarg2;
42875   if (!argp2) {
42876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42877     return 0;
42878   }
42879   arg2 = *argp2;
42880   {
42881     try {
42882       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42883     } catch (std::out_of_range& e) {
42884       {
42885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42886       };
42887     } catch (std::exception& e) {
42888       {
42889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42890       };
42891     } catch (...) {
42892       {
42893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42894       };
42895     }
42896   }
42897   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42898
42899   //argout typemap for const std::string&
42900
42901   return jresult;
42902 }
42903
42904
42905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
42906   void * jresult ;
42907   Dali::BaseHandle arg1 ;
42908   Dali::BaseHandle *argp1 ;
42909   Dali::ResourceImage result;
42910
42911   argp1 = (Dali::BaseHandle *)jarg1;
42912   if (!argp1) {
42913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42914     return 0;
42915   }
42916   arg1 = *argp1;
42917   {
42918     try {
42919       result = Dali::ResourceImage::DownCast(arg1);
42920     } catch (std::out_of_range& e) {
42921       {
42922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42923       };
42924     } catch (std::exception& e) {
42925       {
42926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42927       };
42928     } catch (...) {
42929       {
42930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42931       };
42932     }
42933   }
42934   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42935   return jresult;
42936 }
42937
42938
42939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
42940   int jresult ;
42941   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42942   Dali::LoadingState result;
42943
42944   arg1 = (Dali::ResourceImage *)jarg1;
42945   {
42946     try {
42947       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
42948     } catch (std::out_of_range& e) {
42949       {
42950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42951       };
42952     } catch (std::exception& e) {
42953       {
42954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42955       };
42956     } catch (...) {
42957       {
42958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42959       };
42960     }
42961   }
42962   jresult = (int)result;
42963   return jresult;
42964 }
42965
42966
42967 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
42968   char * jresult ;
42969   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42970   std::string result;
42971
42972   arg1 = (Dali::ResourceImage *)jarg1;
42973   {
42974     try {
42975       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
42976     } catch (std::out_of_range& e) {
42977       {
42978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42979       };
42980     } catch (std::exception& e) {
42981       {
42982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42983       };
42984     } catch (...) {
42985       {
42986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42987       };
42988     }
42989   }
42990   jresult = SWIG_csharp_string_callback((&result)->c_str());
42991   return jresult;
42992 }
42993
42994
42995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
42996   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42997
42998   arg1 = (Dali::ResourceImage *)jarg1;
42999   {
43000     try {
43001       (arg1)->Reload();
43002     } catch (std::out_of_range& e) {
43003       {
43004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43005       };
43006     } catch (std::exception& e) {
43007       {
43008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43009       };
43010     } catch (...) {
43011       {
43012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43013       };
43014     }
43015   }
43016 }
43017
43018
43019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
43020   void * jresult ;
43021   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
43022   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
43023
43024   arg1 = (Dali::ResourceImage *)jarg1;
43025   {
43026     try {
43027       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
43028     } catch (std::out_of_range& e) {
43029       {
43030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43031       };
43032     } catch (std::exception& e) {
43033       {
43034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43035       };
43036     } catch (...) {
43037       {
43038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43039       };
43040     }
43041   }
43042   jresult = (void *)result;
43043   return jresult;
43044 }
43045
43046
43047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
43048   void * jresult ;
43049   Dali::FrameBufferImage *result = 0 ;
43050
43051   {
43052     try {
43053       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
43054     } catch (std::out_of_range& e) {
43055       {
43056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43057       };
43058     } catch (std::exception& e) {
43059       {
43060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43061       };
43062     } catch (...) {
43063       {
43064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43065       };
43066     }
43067   }
43068   jresult = (void *)result;
43069   return jresult;
43070 }
43071
43072
43073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
43074   void * jresult ;
43075   unsigned int arg1 ;
43076   unsigned int arg2 ;
43077   Dali::Pixel::Format arg3 ;
43078   Dali::RenderBuffer::Format arg4 ;
43079   Dali::FrameBufferImage result;
43080
43081   arg1 = (unsigned int)jarg1;
43082   arg2 = (unsigned int)jarg2;
43083   arg3 = (Dali::Pixel::Format)jarg3;
43084   arg4 = (Dali::RenderBuffer::Format)jarg4;
43085   {
43086     try {
43087       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
43088     } catch (std::out_of_range& e) {
43089       {
43090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43091       };
43092     } catch (std::exception& e) {
43093       {
43094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43095       };
43096     } catch (...) {
43097       {
43098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43099       };
43100     }
43101   }
43102   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43103   return jresult;
43104 }
43105
43106
43107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
43108   void * jresult ;
43109   unsigned int arg1 ;
43110   unsigned int arg2 ;
43111   Dali::Pixel::Format arg3 ;
43112   Dali::FrameBufferImage result;
43113
43114   arg1 = (unsigned int)jarg1;
43115   arg2 = (unsigned int)jarg2;
43116   arg3 = (Dali::Pixel::Format)jarg3;
43117   {
43118     try {
43119       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
43120     } catch (std::out_of_range& e) {
43121       {
43122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43123       };
43124     } catch (std::exception& e) {
43125       {
43126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43127       };
43128     } catch (...) {
43129       {
43130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43131       };
43132     }
43133   }
43134   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43135   return jresult;
43136 }
43137
43138
43139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
43140   void * jresult ;
43141   unsigned int arg1 ;
43142   unsigned int arg2 ;
43143   Dali::FrameBufferImage result;
43144
43145   arg1 = (unsigned int)jarg1;
43146   arg2 = (unsigned int)jarg2;
43147   {
43148     try {
43149       result = Dali::FrameBufferImage::New(arg1,arg2);
43150     } catch (std::out_of_range& e) {
43151       {
43152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43153       };
43154     } catch (std::exception& e) {
43155       {
43156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43157       };
43158     } catch (...) {
43159       {
43160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43161       };
43162     }
43163   }
43164   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43165   return jresult;
43166 }
43167
43168
43169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
43170   void * jresult ;
43171   unsigned int arg1 ;
43172   Dali::FrameBufferImage result;
43173
43174   arg1 = (unsigned int)jarg1;
43175   {
43176     try {
43177       result = Dali::FrameBufferImage::New(arg1);
43178     } catch (std::out_of_range& e) {
43179       {
43180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43181       };
43182     } catch (std::exception& e) {
43183       {
43184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43185       };
43186     } catch (...) {
43187       {
43188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43189       };
43190     }
43191   }
43192   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43193   return jresult;
43194 }
43195
43196
43197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
43198   void * jresult ;
43199   Dali::FrameBufferImage result;
43200
43201   {
43202     try {
43203       result = Dali::FrameBufferImage::New();
43204     } catch (std::out_of_range& e) {
43205       {
43206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43207       };
43208     } catch (std::exception& e) {
43209       {
43210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43211       };
43212     } catch (...) {
43213       {
43214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43215       };
43216     }
43217   }
43218   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43219   return jresult;
43220 }
43221
43222
43223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
43224   void * jresult ;
43225   Dali::NativeImageInterface *arg1 = 0 ;
43226   Dali::FrameBufferImage result;
43227
43228   arg1 = (Dali::NativeImageInterface *)jarg1;
43229   if (!arg1) {
43230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
43231     return 0;
43232   }
43233   {
43234     try {
43235       result = Dali::FrameBufferImage::New(*arg1);
43236     } catch (std::out_of_range& e) {
43237       {
43238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43239       };
43240     } catch (std::exception& e) {
43241       {
43242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43243       };
43244     } catch (...) {
43245       {
43246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43247       };
43248     }
43249   }
43250   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43251   return jresult;
43252 }
43253
43254
43255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
43256   void * jresult ;
43257   Dali::BaseHandle arg1 ;
43258   Dali::BaseHandle *argp1 ;
43259   Dali::FrameBufferImage result;
43260
43261   argp1 = (Dali::BaseHandle *)jarg1;
43262   if (!argp1) {
43263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43264     return 0;
43265   }
43266   arg1 = *argp1;
43267   {
43268     try {
43269       result = Dali::FrameBufferImage::DownCast(arg1);
43270     } catch (std::out_of_range& e) {
43271       {
43272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43273       };
43274     } catch (std::exception& e) {
43275       {
43276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43277       };
43278     } catch (...) {
43279       {
43280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43281       };
43282     }
43283   }
43284   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43285   return jresult;
43286 }
43287
43288
43289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
43290   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
43291
43292   arg1 = (Dali::FrameBufferImage *)jarg1;
43293   {
43294     try {
43295       delete arg1;
43296     } catch (std::out_of_range& e) {
43297       {
43298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43299       };
43300     } catch (std::exception& e) {
43301       {
43302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43303       };
43304     } catch (...) {
43305       {
43306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43307       };
43308     }
43309   }
43310 }
43311
43312
43313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
43314   void * jresult ;
43315   Dali::FrameBufferImage *arg1 = 0 ;
43316   Dali::FrameBufferImage *result = 0 ;
43317
43318   arg1 = (Dali::FrameBufferImage *)jarg1;
43319   if (!arg1) {
43320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
43321     return 0;
43322   }
43323   {
43324     try {
43325       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
43326     } catch (std::out_of_range& e) {
43327       {
43328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43329       };
43330     } catch (std::exception& e) {
43331       {
43332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43333       };
43334     } catch (...) {
43335       {
43336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43337       };
43338     }
43339   }
43340   jresult = (void *)result;
43341   return jresult;
43342 }
43343
43344
43345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
43346   void * jresult ;
43347   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
43348   Dali::FrameBufferImage *arg2 = 0 ;
43349   Dali::FrameBufferImage *result = 0 ;
43350
43351   arg1 = (Dali::FrameBufferImage *)jarg1;
43352   arg2 = (Dali::FrameBufferImage *)jarg2;
43353   if (!arg2) {
43354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
43355     return 0;
43356   }
43357   {
43358     try {
43359       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
43360     } catch (std::out_of_range& e) {
43361       {
43362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43363       };
43364     } catch (std::exception& e) {
43365       {
43366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43367       };
43368     } catch (...) {
43369       {
43370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43371       };
43372     }
43373   }
43374   jresult = (void *)result;
43375   return jresult;
43376 }
43377
43378
43379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
43380   void * jresult ;
43381   Dali::NinePatchImage *result = 0 ;
43382
43383   {
43384     try {
43385       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
43386     } catch (std::out_of_range& e) {
43387       {
43388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43389       };
43390     } catch (std::exception& e) {
43391       {
43392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43393       };
43394     } catch (...) {
43395       {
43396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43397       };
43398     }
43399   }
43400   jresult = (void *)result;
43401   return jresult;
43402 }
43403
43404
43405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
43406   void * jresult ;
43407   std::string *arg1 = 0 ;
43408   Dali::NinePatchImage result;
43409
43410   if (!jarg1) {
43411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43412     return 0;
43413   }
43414   std::string arg1_str(jarg1);
43415   arg1 = &arg1_str;
43416   {
43417     try {
43418       result = Dali::NinePatchImage::New((std::string const &)*arg1);
43419     } catch (std::out_of_range& e) {
43420       {
43421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43422       };
43423     } catch (std::exception& e) {
43424       {
43425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43426       };
43427     } catch (...) {
43428       {
43429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43430       };
43431     }
43432   }
43433   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
43434
43435   //argout typemap for const std::string&
43436
43437   return jresult;
43438 }
43439
43440
43441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
43442   void * jresult ;
43443   Dali::BaseHandle arg1 ;
43444   Dali::BaseHandle *argp1 ;
43445   Dali::NinePatchImage result;
43446
43447   argp1 = (Dali::BaseHandle *)jarg1;
43448   if (!argp1) {
43449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43450     return 0;
43451   }
43452   arg1 = *argp1;
43453   {
43454     try {
43455       result = Dali::NinePatchImage::DownCast(arg1);
43456     } catch (std::out_of_range& e) {
43457       {
43458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43459       };
43460     } catch (std::exception& e) {
43461       {
43462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43463       };
43464     } catch (...) {
43465       {
43466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43467       };
43468     }
43469   }
43470   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
43471   return jresult;
43472 }
43473
43474
43475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
43476   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43477
43478   arg1 = (Dali::NinePatchImage *)jarg1;
43479   {
43480     try {
43481       delete arg1;
43482     } catch (std::out_of_range& e) {
43483       {
43484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43485       };
43486     } catch (std::exception& e) {
43487       {
43488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43489       };
43490     } catch (...) {
43491       {
43492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43493       };
43494     }
43495   }
43496 }
43497
43498
43499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
43500   void * jresult ;
43501   Dali::NinePatchImage *arg1 = 0 ;
43502   Dali::NinePatchImage *result = 0 ;
43503
43504   arg1 = (Dali::NinePatchImage *)jarg1;
43505   if (!arg1) {
43506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43507     return 0;
43508   }
43509   {
43510     try {
43511       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
43512     } catch (std::out_of_range& e) {
43513       {
43514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43515       };
43516     } catch (std::exception& e) {
43517       {
43518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43519       };
43520     } catch (...) {
43521       {
43522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43523       };
43524     }
43525   }
43526   jresult = (void *)result;
43527   return jresult;
43528 }
43529
43530
43531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
43532   void * jresult ;
43533   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43534   Dali::NinePatchImage *arg2 = 0 ;
43535   Dali::NinePatchImage *result = 0 ;
43536
43537   arg1 = (Dali::NinePatchImage *)jarg1;
43538   arg2 = (Dali::NinePatchImage *)jarg2;
43539   if (!arg2) {
43540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43541     return 0;
43542   }
43543   {
43544     try {
43545       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
43546     } catch (std::out_of_range& e) {
43547       {
43548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43549       };
43550     } catch (std::exception& e) {
43551       {
43552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43553       };
43554     } catch (...) {
43555       {
43556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43557       };
43558     }
43559   }
43560   jresult = (void *)result;
43561   return jresult;
43562 }
43563
43564
43565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
43566   void * jresult ;
43567   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43568   Dali::Vector4 result;
43569
43570   arg1 = (Dali::NinePatchImage *)jarg1;
43571   {
43572     try {
43573       result = (arg1)->GetStretchBorders();
43574     } catch (std::out_of_range& e) {
43575       {
43576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43577       };
43578     } catch (std::exception& e) {
43579       {
43580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43581       };
43582     } catch (...) {
43583       {
43584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43585       };
43586     }
43587   }
43588   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
43589   return jresult;
43590 }
43591
43592
43593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
43594   void * jresult ;
43595   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43596   Dali::NinePatchImage::StretchRanges *result = 0 ;
43597
43598   arg1 = (Dali::NinePatchImage *)jarg1;
43599   {
43600     try {
43601       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
43602     } catch (std::out_of_range& e) {
43603       {
43604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43605       };
43606     } catch (std::exception& e) {
43607       {
43608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43609       };
43610     } catch (...) {
43611       {
43612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43613       };
43614     }
43615   }
43616   jresult = (void *)result;
43617   return jresult;
43618 }
43619
43620
43621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
43622   void * jresult ;
43623   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43624   Dali::NinePatchImage::StretchRanges *result = 0 ;
43625
43626   arg1 = (Dali::NinePatchImage *)jarg1;
43627   {
43628     try {
43629       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
43630     } catch (std::out_of_range& e) {
43631       {
43632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43633       };
43634     } catch (std::exception& e) {
43635       {
43636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43637       };
43638     } catch (...) {
43639       {
43640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43641       };
43642     }
43643   }
43644   jresult = (void *)result;
43645   return jresult;
43646 }
43647
43648
43649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
43650   void * jresult ;
43651   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43652   Dali::Rect< int > result;
43653
43654   arg1 = (Dali::NinePatchImage *)jarg1;
43655   {
43656     try {
43657       result = (arg1)->GetChildRectangle();
43658     } catch (std::out_of_range& e) {
43659       {
43660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43661       };
43662     } catch (std::exception& e) {
43663       {
43664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43665       };
43666     } catch (...) {
43667       {
43668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43669       };
43670     }
43671   }
43672   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
43673   return jresult;
43674 }
43675
43676
43677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
43678   void * jresult ;
43679   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43680   Dali::BufferImage result;
43681
43682   arg1 = (Dali::NinePatchImage *)jarg1;
43683   {
43684     try {
43685       result = (arg1)->CreateCroppedBufferImage();
43686     } catch (std::out_of_range& e) {
43687       {
43688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43689       };
43690     } catch (std::exception& e) {
43691       {
43692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43693       };
43694     } catch (...) {
43695       {
43696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43697       };
43698     }
43699   }
43700   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
43701   return jresult;
43702 }
43703
43704
43705 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
43706   unsigned int jresult ;
43707   std::string *arg1 = 0 ;
43708   bool result;
43709
43710   if (!jarg1) {
43711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43712     return 0;
43713   }
43714   std::string arg1_str(jarg1);
43715   arg1 = &arg1_str;
43716   {
43717     try {
43718       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
43719     } catch (std::out_of_range& e) {
43720       {
43721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43722       };
43723     } catch (std::exception& e) {
43724       {
43725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43726       };
43727     } catch (...) {
43728       {
43729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43730       };
43731     }
43732   }
43733   jresult = result;
43734
43735   //argout typemap for const std::string&
43736
43737   return jresult;
43738 }
43739
43740
43741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
43742   int jresult ;
43743   int result;
43744
43745   result = (int)Dali::CameraActor::Property::TYPE;
43746   jresult = (int)result;
43747   return jresult;
43748 }
43749
43750
43751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
43752   int jresult ;
43753   int result;
43754
43755   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
43756   jresult = (int)result;
43757   return jresult;
43758 }
43759
43760
43761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
43762   int jresult ;
43763   int result;
43764
43765   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
43766   jresult = (int)result;
43767   return jresult;
43768 }
43769
43770
43771 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
43772   int jresult ;
43773   int result;
43774
43775   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
43776   jresult = (int)result;
43777   return jresult;
43778 }
43779
43780
43781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
43782   int jresult ;
43783   int result;
43784
43785   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
43786   jresult = (int)result;
43787   return jresult;
43788 }
43789
43790
43791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
43792   int jresult ;
43793   int result;
43794
43795   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
43796   jresult = (int)result;
43797   return jresult;
43798 }
43799
43800
43801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
43802   int jresult ;
43803   int result;
43804
43805   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
43806   jresult = (int)result;
43807   return jresult;
43808 }
43809
43810
43811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
43812   int jresult ;
43813   int result;
43814
43815   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
43816   jresult = (int)result;
43817   return jresult;
43818 }
43819
43820
43821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
43822   int jresult ;
43823   int result;
43824
43825   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
43826   jresult = (int)result;
43827   return jresult;
43828 }
43829
43830
43831 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
43832   int jresult ;
43833   int result;
43834
43835   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
43836   jresult = (int)result;
43837   return jresult;
43838 }
43839
43840
43841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
43842   int jresult ;
43843   int result;
43844
43845   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
43846   jresult = (int)result;
43847   return jresult;
43848 }
43849
43850
43851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
43852   int jresult ;
43853   int result;
43854
43855   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
43856   jresult = (int)result;
43857   return jresult;
43858 }
43859
43860
43861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
43862   int jresult ;
43863   int result;
43864
43865   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
43866   jresult = (int)result;
43867   return jresult;
43868 }
43869
43870
43871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
43872   int jresult ;
43873   int result;
43874
43875   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
43876   jresult = (int)result;
43877   return jresult;
43878 }
43879
43880
43881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
43882   void * jresult ;
43883   Dali::CameraActor::Property *result = 0 ;
43884
43885   {
43886     try {
43887       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
43888     } catch (std::out_of_range& e) {
43889       {
43890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43891       };
43892     } catch (std::exception& e) {
43893       {
43894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43895       };
43896     } catch (...) {
43897       {
43898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43899       };
43900     }
43901   }
43902   jresult = (void *)result;
43903   return jresult;
43904 }
43905
43906
43907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
43908   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
43909
43910   arg1 = (Dali::CameraActor::Property *)jarg1;
43911   {
43912     try {
43913       delete arg1;
43914     } catch (std::out_of_range& e) {
43915       {
43916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43917       };
43918     } catch (std::exception& e) {
43919       {
43920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43921       };
43922     } catch (...) {
43923       {
43924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43925       };
43926     }
43927   }
43928 }
43929
43930
43931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
43932   void * jresult ;
43933   Dali::CameraActor *result = 0 ;
43934
43935   {
43936     try {
43937       result = (Dali::CameraActor *)new Dali::CameraActor();
43938     } catch (std::out_of_range& e) {
43939       {
43940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43941       };
43942     } catch (std::exception& e) {
43943       {
43944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43945       };
43946     } catch (...) {
43947       {
43948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43949       };
43950     }
43951   }
43952   jresult = (void *)result;
43953   return jresult;
43954 }
43955
43956
43957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
43958   void * jresult ;
43959   Dali::CameraActor result;
43960
43961   {
43962     try {
43963       result = Dali::CameraActor::New();
43964     } catch (std::out_of_range& e) {
43965       {
43966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43967       };
43968     } catch (std::exception& e) {
43969       {
43970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43971       };
43972     } catch (...) {
43973       {
43974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43975       };
43976     }
43977   }
43978   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
43979   return jresult;
43980 }
43981
43982
43983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
43984   void * jresult ;
43985   Dali::Size *arg1 = 0 ;
43986   Dali::CameraActor result;
43987
43988   arg1 = (Dali::Size *)jarg1;
43989   if (!arg1) {
43990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
43991     return 0;
43992   }
43993   {
43994     try {
43995       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
43996     } catch (std::out_of_range& e) {
43997       {
43998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43999       };
44000     } catch (std::exception& e) {
44001       {
44002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44003       };
44004     } catch (...) {
44005       {
44006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44007       };
44008     }
44009   }
44010   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44011   return jresult;
44012 }
44013
44014
44015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
44016   void * jresult ;
44017   Dali::BaseHandle arg1 ;
44018   Dali::BaseHandle *argp1 ;
44019   Dali::CameraActor result;
44020
44021   argp1 = (Dali::BaseHandle *)jarg1;
44022   if (!argp1) {
44023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44024     return 0;
44025   }
44026   arg1 = *argp1;
44027   {
44028     try {
44029       result = Dali::CameraActor::DownCast(arg1);
44030     } catch (std::out_of_range& e) {
44031       {
44032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44033       };
44034     } catch (std::exception& e) {
44035       {
44036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44037       };
44038     } catch (...) {
44039       {
44040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44041       };
44042     }
44043   }
44044   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44045   return jresult;
44046 }
44047
44048
44049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
44050   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44051
44052   arg1 = (Dali::CameraActor *)jarg1;
44053   {
44054     try {
44055       delete arg1;
44056     } catch (std::out_of_range& e) {
44057       {
44058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44059       };
44060     } catch (std::exception& e) {
44061       {
44062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44063       };
44064     } catch (...) {
44065       {
44066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44067       };
44068     }
44069   }
44070 }
44071
44072
44073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
44074   void * jresult ;
44075   Dali::CameraActor *arg1 = 0 ;
44076   Dali::CameraActor *result = 0 ;
44077
44078   arg1 = (Dali::CameraActor *)jarg1;
44079   if (!arg1) {
44080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
44081     return 0;
44082   }
44083   {
44084     try {
44085       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
44086     } catch (std::out_of_range& e) {
44087       {
44088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44089       };
44090     } catch (std::exception& e) {
44091       {
44092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44093       };
44094     } catch (...) {
44095       {
44096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44097       };
44098     }
44099   }
44100   jresult = (void *)result;
44101   return jresult;
44102 }
44103
44104
44105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
44106   void * jresult ;
44107   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44108   Dali::CameraActor *arg2 = 0 ;
44109   Dali::CameraActor *result = 0 ;
44110
44111   arg1 = (Dali::CameraActor *)jarg1;
44112   arg2 = (Dali::CameraActor *)jarg2;
44113   if (!arg2) {
44114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
44115     return 0;
44116   }
44117   {
44118     try {
44119       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
44120     } catch (std::out_of_range& e) {
44121       {
44122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44123       };
44124     } catch (std::exception& e) {
44125       {
44126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44127       };
44128     } catch (...) {
44129       {
44130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44131       };
44132     }
44133   }
44134   jresult = (void *)result;
44135   return jresult;
44136 }
44137
44138
44139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
44140   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44141   Dali::Camera::Type arg2 ;
44142
44143   arg1 = (Dali::CameraActor *)jarg1;
44144   arg2 = (Dali::Camera::Type)jarg2;
44145   {
44146     try {
44147       (arg1)->SetType(arg2);
44148     } catch (std::out_of_range& e) {
44149       {
44150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44151       };
44152     } catch (std::exception& e) {
44153       {
44154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44155       };
44156     } catch (...) {
44157       {
44158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44159       };
44160     }
44161   }
44162 }
44163
44164
44165 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
44166   int jresult ;
44167   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44168   Dali::Camera::Type result;
44169
44170   arg1 = (Dali::CameraActor *)jarg1;
44171   {
44172     try {
44173       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
44174     } catch (std::out_of_range& e) {
44175       {
44176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44177       };
44178     } catch (std::exception& e) {
44179       {
44180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44181       };
44182     } catch (...) {
44183       {
44184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44185       };
44186     }
44187   }
44188   jresult = (int)result;
44189   return jresult;
44190 }
44191
44192
44193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
44194   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44195   Dali::Camera::ProjectionMode arg2 ;
44196
44197   arg1 = (Dali::CameraActor *)jarg1;
44198   arg2 = (Dali::Camera::ProjectionMode)jarg2;
44199   {
44200     try {
44201       (arg1)->SetProjectionMode(arg2);
44202     } catch (std::out_of_range& e) {
44203       {
44204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44205       };
44206     } catch (std::exception& e) {
44207       {
44208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44209       };
44210     } catch (...) {
44211       {
44212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44213       };
44214     }
44215   }
44216 }
44217
44218
44219 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
44220   int jresult ;
44221   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44222   Dali::Camera::ProjectionMode result;
44223
44224   arg1 = (Dali::CameraActor *)jarg1;
44225   {
44226     try {
44227       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
44228     } catch (std::out_of_range& e) {
44229       {
44230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44231       };
44232     } catch (std::exception& e) {
44233       {
44234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44235       };
44236     } catch (...) {
44237       {
44238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44239       };
44240     }
44241   }
44242   jresult = (int)result;
44243   return jresult;
44244 }
44245
44246
44247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
44248   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44249   float arg2 ;
44250
44251   arg1 = (Dali::CameraActor *)jarg1;
44252   arg2 = (float)jarg2;
44253   {
44254     try {
44255       (arg1)->SetFieldOfView(arg2);
44256     } catch (std::out_of_range& e) {
44257       {
44258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44259       };
44260     } catch (std::exception& e) {
44261       {
44262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44263       };
44264     } catch (...) {
44265       {
44266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44267       };
44268     }
44269   }
44270 }
44271
44272
44273 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
44274   float jresult ;
44275   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44276   float result;
44277
44278   arg1 = (Dali::CameraActor *)jarg1;
44279   {
44280     try {
44281       result = (float)(arg1)->GetFieldOfView();
44282     } catch (std::out_of_range& e) {
44283       {
44284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44285       };
44286     } catch (std::exception& e) {
44287       {
44288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44289       };
44290     } catch (...) {
44291       {
44292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44293       };
44294     }
44295   }
44296   jresult = result;
44297   return jresult;
44298 }
44299
44300
44301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
44302   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44303   float arg2 ;
44304
44305   arg1 = (Dali::CameraActor *)jarg1;
44306   arg2 = (float)jarg2;
44307   {
44308     try {
44309       (arg1)->SetAspectRatio(arg2);
44310     } catch (std::out_of_range& e) {
44311       {
44312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44313       };
44314     } catch (std::exception& e) {
44315       {
44316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44317       };
44318     } catch (...) {
44319       {
44320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44321       };
44322     }
44323   }
44324 }
44325
44326
44327 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
44328   float jresult ;
44329   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44330   float result;
44331
44332   arg1 = (Dali::CameraActor *)jarg1;
44333   {
44334     try {
44335       result = (float)(arg1)->GetAspectRatio();
44336     } catch (std::out_of_range& e) {
44337       {
44338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44339       };
44340     } catch (std::exception& e) {
44341       {
44342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44343       };
44344     } catch (...) {
44345       {
44346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44347       };
44348     }
44349   }
44350   jresult = result;
44351   return jresult;
44352 }
44353
44354
44355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
44356   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44357   float arg2 ;
44358
44359   arg1 = (Dali::CameraActor *)jarg1;
44360   arg2 = (float)jarg2;
44361   {
44362     try {
44363       (arg1)->SetNearClippingPlane(arg2);
44364     } catch (std::out_of_range& e) {
44365       {
44366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44367       };
44368     } catch (std::exception& e) {
44369       {
44370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44371       };
44372     } catch (...) {
44373       {
44374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44375       };
44376     }
44377   }
44378 }
44379
44380
44381 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
44382   float jresult ;
44383   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44384   float result;
44385
44386   arg1 = (Dali::CameraActor *)jarg1;
44387   {
44388     try {
44389       result = (float)(arg1)->GetNearClippingPlane();
44390     } catch (std::out_of_range& e) {
44391       {
44392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44393       };
44394     } catch (std::exception& e) {
44395       {
44396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44397       };
44398     } catch (...) {
44399       {
44400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44401       };
44402     }
44403   }
44404   jresult = result;
44405   return jresult;
44406 }
44407
44408
44409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
44410   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44411   float arg2 ;
44412
44413   arg1 = (Dali::CameraActor *)jarg1;
44414   arg2 = (float)jarg2;
44415   {
44416     try {
44417       (arg1)->SetFarClippingPlane(arg2);
44418     } catch (std::out_of_range& e) {
44419       {
44420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44421       };
44422     } catch (std::exception& e) {
44423       {
44424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44425       };
44426     } catch (...) {
44427       {
44428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44429       };
44430     }
44431   }
44432 }
44433
44434
44435 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
44436   float jresult ;
44437   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44438   float result;
44439
44440   arg1 = (Dali::CameraActor *)jarg1;
44441   {
44442     try {
44443       result = (float)(arg1)->GetFarClippingPlane();
44444     } catch (std::out_of_range& e) {
44445       {
44446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44447       };
44448     } catch (std::exception& e) {
44449       {
44450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44451       };
44452     } catch (...) {
44453       {
44454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44455       };
44456     }
44457   }
44458   jresult = result;
44459   return jresult;
44460 }
44461
44462
44463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
44464   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44465   Dali::Vector3 *arg2 = 0 ;
44466
44467   arg1 = (Dali::CameraActor *)jarg1;
44468   arg2 = (Dali::Vector3 *)jarg2;
44469   if (!arg2) {
44470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
44471     return ;
44472   }
44473   {
44474     try {
44475       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
44476     } catch (std::out_of_range& e) {
44477       {
44478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44479       };
44480     } catch (std::exception& e) {
44481       {
44482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44483       };
44484     } catch (...) {
44485       {
44486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44487       };
44488     }
44489   }
44490 }
44491
44492
44493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
44494   void * jresult ;
44495   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44496   Dali::Vector3 result;
44497
44498   arg1 = (Dali::CameraActor *)jarg1;
44499   {
44500     try {
44501       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
44502     } catch (std::out_of_range& e) {
44503       {
44504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44505       };
44506     } catch (std::exception& e) {
44507       {
44508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44509       };
44510     } catch (...) {
44511       {
44512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44513       };
44514     }
44515   }
44516   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
44517   return jresult;
44518 }
44519
44520
44521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
44522   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44523   bool arg2 ;
44524
44525   arg1 = (Dali::CameraActor *)jarg1;
44526   arg2 = jarg2 ? true : false;
44527   {
44528     try {
44529       (arg1)->SetInvertYAxis(arg2);
44530     } catch (std::out_of_range& e) {
44531       {
44532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44533       };
44534     } catch (std::exception& e) {
44535       {
44536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44537       };
44538     } catch (...) {
44539       {
44540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44541       };
44542     }
44543   }
44544 }
44545
44546
44547 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
44548   unsigned int jresult ;
44549   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44550   bool result;
44551
44552   arg1 = (Dali::CameraActor *)jarg1;
44553   {
44554     try {
44555       result = (bool)(arg1)->GetInvertYAxis();
44556     } catch (std::out_of_range& e) {
44557       {
44558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44559       };
44560     } catch (std::exception& e) {
44561       {
44562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44563       };
44564     } catch (...) {
44565       {
44566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44567       };
44568     }
44569   }
44570   jresult = result;
44571   return jresult;
44572 }
44573
44574
44575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
44576   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44577   Dali::Size *arg2 = 0 ;
44578
44579   arg1 = (Dali::CameraActor *)jarg1;
44580   arg2 = (Dali::Size *)jarg2;
44581   if (!arg2) {
44582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44583     return ;
44584   }
44585   {
44586     try {
44587       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
44588     } catch (std::out_of_range& e) {
44589       {
44590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44591       };
44592     } catch (std::exception& e) {
44593       {
44594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44595       };
44596     } catch (...) {
44597       {
44598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44599       };
44600     }
44601   }
44602 }
44603
44604
44605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
44606   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44607   Dali::Size *arg2 = 0 ;
44608
44609   arg1 = (Dali::CameraActor *)jarg1;
44610   arg2 = (Dali::Size *)jarg2;
44611   if (!arg2) {
44612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44613     return ;
44614   }
44615   {
44616     try {
44617       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
44618     } catch (std::out_of_range& e) {
44619       {
44620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44621       };
44622     } catch (std::exception& e) {
44623       {
44624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44625       };
44626     } catch (...) {
44627       {
44628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44629       };
44630     }
44631   }
44632 }
44633
44634
44635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
44636   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44637   float arg2 ;
44638   float arg3 ;
44639   float arg4 ;
44640   float arg5 ;
44641   float arg6 ;
44642   float arg7 ;
44643
44644   arg1 = (Dali::CameraActor *)jarg1;
44645   arg2 = (float)jarg2;
44646   arg3 = (float)jarg3;
44647   arg4 = (float)jarg4;
44648   arg5 = (float)jarg5;
44649   arg6 = (float)jarg6;
44650   arg7 = (float)jarg7;
44651   {
44652     try {
44653       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
44654     } catch (std::out_of_range& e) {
44655       {
44656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44657       };
44658     } catch (std::exception& e) {
44659       {
44660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44661       };
44662     } catch (...) {
44663       {
44664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44665       };
44666     }
44667   }
44668 }
44669
44670
44671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
44672   void * jresult ;
44673   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44674
44675   {
44676     try {
44677       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
44678     } catch (std::out_of_range& e) {
44679       {
44680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44681       };
44682     } catch (std::exception& e) {
44683       {
44684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44685       };
44686     } catch (...) {
44687       {
44688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44689       };
44690     }
44691   }
44692   jresult = (void *)result;
44693   return jresult;
44694 }
44695
44696
44697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
44698   void * jresult ;
44699   std::string arg1 ;
44700   Dali::Property::Value arg2 ;
44701   Dali::Property::Value *argp2 ;
44702   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44703
44704   if (!jarg1) {
44705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44706     return 0;
44707   }
44708   (&arg1)->assign(jarg1);
44709   argp2 = (Dali::Property::Value *)jarg2;
44710   if (!argp2) {
44711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
44712     return 0;
44713   }
44714   arg2 = *argp2;
44715   {
44716     try {
44717       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
44718     } catch (std::out_of_range& e) {
44719       {
44720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44721       };
44722     } catch (std::exception& e) {
44723       {
44724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44725       };
44726     } catch (...) {
44727       {
44728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44729       };
44730     }
44731   }
44732   jresult = (void *)result;
44733   return jresult;
44734 }
44735
44736
44737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
44738   void * jresult ;
44739   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
44740   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44741
44742   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44743   if (!arg1) {
44744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
44745     return 0;
44746   }
44747   {
44748     try {
44749       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);
44750     } catch (std::out_of_range& e) {
44751       {
44752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44753       };
44754     } catch (std::exception& e) {
44755       {
44756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44757       };
44758     } catch (...) {
44759       {
44760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44761       };
44762     }
44763   }
44764   jresult = (void *)result;
44765   return jresult;
44766 }
44767
44768
44769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
44770   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44771   std::string *arg2 = 0 ;
44772
44773   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44774   if (!jarg2) {
44775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44776     return ;
44777   }
44778   std::string arg2_str(jarg2);
44779   arg2 = &arg2_str;
44780   if (arg1) (arg1)->first = *arg2;
44781
44782   //argout typemap for const std::string&
44783
44784 }
44785
44786
44787 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
44788   char * jresult ;
44789   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44790   std::string *result = 0 ;
44791
44792   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44793   result = (std::string *) & ((arg1)->first);
44794   jresult = SWIG_csharp_string_callback(result->c_str());
44795   return jresult;
44796 }
44797
44798
44799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
44800   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44801   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
44802
44803   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44804   arg2 = (Dali::Property::Value *)jarg2;
44805   if (arg1) (arg1)->second = *arg2;
44806 }
44807
44808
44809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
44810   void * jresult ;
44811   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44812   Dali::Property::Value *result = 0 ;
44813
44814   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44815   result = (Dali::Property::Value *)& ((arg1)->second);
44816   jresult = (void *)result;
44817   return jresult;
44818 }
44819
44820
44821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
44822   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44823
44824   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44825   {
44826     try {
44827       delete arg1;
44828     } catch (std::out_of_range& e) {
44829       {
44830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44831       };
44832     } catch (std::exception& e) {
44833       {
44834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44835       };
44836     } catch (...) {
44837       {
44838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44839       };
44840     }
44841   }
44842 }
44843
44844
44845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
44846   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44847
44848   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44849   {
44850     try {
44851       (arg1)->clear();
44852     } catch (std::out_of_range& e) {
44853       {
44854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44855       };
44856     } catch (std::exception& e) {
44857       {
44858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44859       };
44860     } catch (...) {
44861       {
44862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44863       };
44864     }
44865   }
44866 }
44867
44868
44869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
44870   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44871   Dali::TouchPoint *arg2 = 0 ;
44872
44873   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44874   arg2 = (Dali::TouchPoint *)jarg2;
44875   if (!arg2) {
44876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
44877     return ;
44878   }
44879   {
44880     try {
44881       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
44882     } catch (std::out_of_range& e) {
44883       {
44884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44885       };
44886     } catch (std::exception& e) {
44887       {
44888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44889       };
44890     } catch (...) {
44891       {
44892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44893       };
44894     }
44895   }
44896 }
44897
44898
44899 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
44900   unsigned long jresult ;
44901   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44902   std::vector< Dali::TouchPoint >::size_type result;
44903
44904   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44905   {
44906     try {
44907       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
44908     } catch (std::out_of_range& e) {
44909       {
44910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44911       };
44912     } catch (std::exception& e) {
44913       {
44914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44915       };
44916     } catch (...) {
44917       {
44918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44919       };
44920     }
44921   }
44922   jresult = (unsigned long)result;
44923   return jresult;
44924 }
44925
44926
44927 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
44928   unsigned long jresult ;
44929   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44930   std::vector< Dali::TouchPoint >::size_type result;
44931
44932   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44933   {
44934     try {
44935       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
44936     } catch (std::out_of_range& e) {
44937       {
44938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44939       };
44940     } catch (std::exception& e) {
44941       {
44942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44943       };
44944     } catch (...) {
44945       {
44946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44947       };
44948     }
44949   }
44950   jresult = (unsigned long)result;
44951   return jresult;
44952 }
44953
44954
44955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
44956   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44957   std::vector< Dali::TouchPoint >::size_type arg2 ;
44958
44959   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44960   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
44961   {
44962     try {
44963       (arg1)->reserve(arg2);
44964     } catch (std::out_of_range& e) {
44965       {
44966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44967       };
44968     } catch (std::exception& e) {
44969       {
44970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44971       };
44972     } catch (...) {
44973       {
44974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44975       };
44976     }
44977   }
44978 }
44979
44980
44981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
44982   void * jresult ;
44983   std::vector< Dali::TouchPoint > *result = 0 ;
44984
44985   {
44986     try {
44987       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
44988     } catch (std::out_of_range& e) {
44989       {
44990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44991       };
44992     } catch (std::exception& e) {
44993       {
44994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44995       };
44996     } catch (...) {
44997       {
44998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44999       };
45000     }
45001   }
45002   jresult = (void *)result;
45003   return jresult;
45004 }
45005
45006
45007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
45008   void * jresult ;
45009   std::vector< Dali::TouchPoint > *arg1 = 0 ;
45010   std::vector< Dali::TouchPoint > *result = 0 ;
45011
45012   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45013   if (!arg1) {
45014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45015     return 0;
45016   }
45017   {
45018     try {
45019       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
45020     } catch (std::out_of_range& e) {
45021       {
45022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45023       };
45024     } catch (std::exception& e) {
45025       {
45026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45027       };
45028     } catch (...) {
45029       {
45030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45031       };
45032     }
45033   }
45034   jresult = (void *)result;
45035   return jresult;
45036 }
45037
45038
45039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
45040   void * jresult ;
45041   int arg1 ;
45042   std::vector< Dali::TouchPoint > *result = 0 ;
45043
45044   arg1 = (int)jarg1;
45045   {
45046     try {
45047       try {
45048         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
45049       }
45050       catch(std::out_of_range &_e) {
45051         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45052         return 0;
45053       }
45054
45055     } catch (std::out_of_range& e) {
45056       {
45057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45058       };
45059     } catch (std::exception& e) {
45060       {
45061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45062       };
45063     } catch (...) {
45064       {
45065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45066       };
45067     }
45068   }
45069   jresult = (void *)result;
45070   return jresult;
45071 }
45072
45073
45074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
45075   void * jresult ;
45076   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45077   int arg2 ;
45078   SwigValueWrapper< Dali::TouchPoint > result;
45079
45080   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45081   arg2 = (int)jarg2;
45082   {
45083     try {
45084       try {
45085         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
45086       }
45087       catch(std::out_of_range &_e) {
45088         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45089         return 0;
45090       }
45091
45092     } catch (std::out_of_range& e) {
45093       {
45094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45095       };
45096     } catch (std::exception& e) {
45097       {
45098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45099       };
45100     } catch (...) {
45101       {
45102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45103       };
45104     }
45105   }
45106   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
45107   return jresult;
45108 }
45109
45110
45111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
45112   void * jresult ;
45113   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45114   int arg2 ;
45115   Dali::TouchPoint *result = 0 ;
45116
45117   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45118   arg2 = (int)jarg2;
45119   {
45120     try {
45121       try {
45122         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
45123       }
45124       catch(std::out_of_range &_e) {
45125         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45126         return 0;
45127       }
45128
45129     } catch (std::out_of_range& e) {
45130       {
45131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45132       };
45133     } catch (std::exception& e) {
45134       {
45135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45136       };
45137     } catch (...) {
45138       {
45139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45140       };
45141     }
45142   }
45143   jresult = (void *)result;
45144   return jresult;
45145 }
45146
45147
45148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
45149   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45150   int arg2 ;
45151   Dali::TouchPoint *arg3 = 0 ;
45152
45153   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45154   arg2 = (int)jarg2;
45155   arg3 = (Dali::TouchPoint *)jarg3;
45156   if (!arg3) {
45157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45158     return ;
45159   }
45160   {
45161     try {
45162       try {
45163         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
45164       }
45165       catch(std::out_of_range &_e) {
45166         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45167         return ;
45168       }
45169
45170     } catch (std::out_of_range& e) {
45171       {
45172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45173       };
45174     } catch (std::exception& e) {
45175       {
45176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45177       };
45178     } catch (...) {
45179       {
45180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45181       };
45182     }
45183   }
45184 }
45185
45186
45187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
45188   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45189   std::vector< Dali::TouchPoint > *arg2 = 0 ;
45190
45191   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45192   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
45193   if (!arg2) {
45194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45195     return ;
45196   }
45197   {
45198     try {
45199       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
45200     } catch (std::out_of_range& e) {
45201       {
45202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45203       };
45204     } catch (std::exception& e) {
45205       {
45206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45207       };
45208     } catch (...) {
45209       {
45210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45211       };
45212     }
45213   }
45214 }
45215
45216
45217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
45218   void * jresult ;
45219   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45220   int arg2 ;
45221   int arg3 ;
45222   std::vector< Dali::TouchPoint > *result = 0 ;
45223
45224   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45225   arg2 = (int)jarg2;
45226   arg3 = (int)jarg3;
45227   {
45228     try {
45229       try {
45230         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
45231       }
45232       catch(std::out_of_range &_e) {
45233         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45234         return 0;
45235       }
45236       catch(std::invalid_argument &_e) {
45237         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45238         return 0;
45239       }
45240
45241     } catch (std::out_of_range& e) {
45242       {
45243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45244       };
45245     } catch (std::exception& e) {
45246       {
45247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45248       };
45249     } catch (...) {
45250       {
45251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45252       };
45253     }
45254   }
45255   jresult = (void *)result;
45256   return jresult;
45257 }
45258
45259
45260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
45261   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45262   int arg2 ;
45263   Dali::TouchPoint *arg3 = 0 ;
45264
45265   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45266   arg2 = (int)jarg2;
45267   arg3 = (Dali::TouchPoint *)jarg3;
45268   if (!arg3) {
45269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45270     return ;
45271   }
45272   {
45273     try {
45274       try {
45275         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
45276       }
45277       catch(std::out_of_range &_e) {
45278         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45279         return ;
45280       }
45281
45282     } catch (std::out_of_range& e) {
45283       {
45284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45285       };
45286     } catch (std::exception& e) {
45287       {
45288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45289       };
45290     } catch (...) {
45291       {
45292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45293       };
45294     }
45295   }
45296 }
45297
45298
45299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
45300   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45301   int arg2 ;
45302   std::vector< Dali::TouchPoint > *arg3 = 0 ;
45303
45304   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45305   arg2 = (int)jarg2;
45306   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
45307   if (!arg3) {
45308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45309     return ;
45310   }
45311   {
45312     try {
45313       try {
45314         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
45315       }
45316       catch(std::out_of_range &_e) {
45317         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45318         return ;
45319       }
45320
45321     } catch (std::out_of_range& e) {
45322       {
45323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45324       };
45325     } catch (std::exception& e) {
45326       {
45327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45328       };
45329     } catch (...) {
45330       {
45331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45332       };
45333     }
45334   }
45335 }
45336
45337
45338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
45339   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45340   int arg2 ;
45341
45342   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45343   arg2 = (int)jarg2;
45344   {
45345     try {
45346       try {
45347         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
45348       }
45349       catch(std::out_of_range &_e) {
45350         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45351         return ;
45352       }
45353
45354     } catch (std::out_of_range& e) {
45355       {
45356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45357       };
45358     } catch (std::exception& e) {
45359       {
45360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45361       };
45362     } catch (...) {
45363       {
45364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45365       };
45366     }
45367   }
45368 }
45369
45370
45371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
45372   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45373   int arg2 ;
45374   int arg3 ;
45375
45376   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45377   arg2 = (int)jarg2;
45378   arg3 = (int)jarg3;
45379   {
45380     try {
45381       try {
45382         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
45383       }
45384       catch(std::out_of_range &_e) {
45385         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45386         return ;
45387       }
45388       catch(std::invalid_argument &_e) {
45389         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45390         return ;
45391       }
45392
45393     } catch (std::out_of_range& e) {
45394       {
45395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45396       };
45397     } catch (std::exception& e) {
45398       {
45399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45400       };
45401     } catch (...) {
45402       {
45403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45404       };
45405     }
45406   }
45407 }
45408
45409
45410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
45411   void * jresult ;
45412   Dali::TouchPoint *arg1 = 0 ;
45413   int arg2 ;
45414   std::vector< Dali::TouchPoint > *result = 0 ;
45415
45416   arg1 = (Dali::TouchPoint *)jarg1;
45417   if (!arg1) {
45418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45419     return 0;
45420   }
45421   arg2 = (int)jarg2;
45422   {
45423     try {
45424       try {
45425         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
45426       }
45427       catch(std::out_of_range &_e) {
45428         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45429         return 0;
45430       }
45431
45432     } catch (std::out_of_range& e) {
45433       {
45434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45435       };
45436     } catch (std::exception& e) {
45437       {
45438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45439       };
45440     } catch (...) {
45441       {
45442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45443       };
45444     }
45445   }
45446   jresult = (void *)result;
45447   return jresult;
45448 }
45449
45450
45451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
45452   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45453
45454   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45455   {
45456     try {
45457       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
45458     } catch (std::out_of_range& e) {
45459       {
45460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45461       };
45462     } catch (std::exception& e) {
45463       {
45464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45465       };
45466     } catch (...) {
45467       {
45468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45469       };
45470     }
45471   }
45472 }
45473
45474
45475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
45476   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45477   int arg2 ;
45478   int arg3 ;
45479
45480   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45481   arg2 = (int)jarg2;
45482   arg3 = (int)jarg3;
45483   {
45484     try {
45485       try {
45486         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
45487       }
45488       catch(std::out_of_range &_e) {
45489         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45490         return ;
45491       }
45492       catch(std::invalid_argument &_e) {
45493         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45494         return ;
45495       }
45496
45497     } catch (std::out_of_range& e) {
45498       {
45499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45500       };
45501     } catch (std::exception& e) {
45502       {
45503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45504       };
45505     } catch (...) {
45506       {
45507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45508       };
45509     }
45510   }
45511 }
45512
45513
45514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
45515   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45516   int arg2 ;
45517   std::vector< Dali::TouchPoint > *arg3 = 0 ;
45518
45519   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45520   arg2 = (int)jarg2;
45521   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
45522   if (!arg3) {
45523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45524     return ;
45525   }
45526   {
45527     try {
45528       try {
45529         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
45530       }
45531       catch(std::out_of_range &_e) {
45532         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45533         return ;
45534       }
45535
45536     } catch (std::out_of_range& e) {
45537       {
45538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45539       };
45540     } catch (std::exception& e) {
45541       {
45542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45543       };
45544     } catch (...) {
45545       {
45546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45547       };
45548     }
45549   }
45550 }
45551
45552
45553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
45554   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45555
45556   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45557   {
45558     try {
45559       delete arg1;
45560     } catch (std::out_of_range& e) {
45561       {
45562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45563       };
45564     } catch (std::exception& e) {
45565       {
45566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45567       };
45568     } catch (...) {
45569       {
45570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45571       };
45572     }
45573   }
45574 }
45575
45576
45577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
45578   void * jresult ;
45579   Dali::Rect< int > *result = 0 ;
45580
45581   {
45582     try {
45583       result = (Dali::Rect< int > *)new Dali::Rect< int >();
45584     } catch (std::out_of_range& e) {
45585       {
45586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45587       };
45588     } catch (std::exception& e) {
45589       {
45590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45591       };
45592     } catch (...) {
45593       {
45594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45595       };
45596     }
45597   }
45598   jresult = (void *)result;
45599   return jresult;
45600 }
45601
45602
45603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
45604   void * jresult ;
45605   int arg1 ;
45606   int arg2 ;
45607   int arg3 ;
45608   int arg4 ;
45609   Dali::Rect< int > *result = 0 ;
45610
45611   arg1 = (int)jarg1;
45612   arg2 = (int)jarg2;
45613   arg3 = (int)jarg3;
45614   arg4 = (int)jarg4;
45615   {
45616     try {
45617       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
45618     } catch (std::out_of_range& e) {
45619       {
45620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45621       };
45622     } catch (std::exception& e) {
45623       {
45624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45625       };
45626     } catch (...) {
45627       {
45628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45629       };
45630     }
45631   }
45632   jresult = (void *)result;
45633   return jresult;
45634 }
45635
45636
45637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
45638   void * jresult ;
45639   Dali::Rect< int > *arg1 = 0 ;
45640   Dali::Rect< int > *result = 0 ;
45641
45642   arg1 = (Dali::Rect< int > *)jarg1;
45643   if (!arg1) {
45644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45645     return 0;
45646   }
45647   {
45648     try {
45649       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
45650     } catch (std::out_of_range& e) {
45651       {
45652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45653       };
45654     } catch (std::exception& e) {
45655       {
45656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45657       };
45658     } catch (...) {
45659       {
45660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45661       };
45662     }
45663   }
45664   jresult = (void *)result;
45665   return jresult;
45666 }
45667
45668
45669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
45670   void * jresult ;
45671   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45672   Dali::Rect< int > *arg2 = 0 ;
45673   Dali::Rect< int > *result = 0 ;
45674
45675   arg1 = (Dali::Rect< int > *)jarg1;
45676   arg2 = (Dali::Rect< int > *)jarg2;
45677   if (!arg2) {
45678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45679     return 0;
45680   }
45681   {
45682     try {
45683       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
45684     } catch (std::out_of_range& e) {
45685       {
45686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45687       };
45688     } catch (std::exception& e) {
45689       {
45690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45691       };
45692     } catch (...) {
45693       {
45694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45695       };
45696     }
45697   }
45698   jresult = (void *)result;
45699   return jresult;
45700 }
45701
45702
45703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
45704   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45705   int arg2 ;
45706   int arg3 ;
45707   int arg4 ;
45708   int arg5 ;
45709
45710   arg1 = (Dali::Rect< int > *)jarg1;
45711   arg2 = (int)jarg2;
45712   arg3 = (int)jarg3;
45713   arg4 = (int)jarg4;
45714   arg5 = (int)jarg5;
45715   {
45716     try {
45717       (arg1)->Set(arg2,arg3,arg4,arg5);
45718     } catch (std::out_of_range& e) {
45719       {
45720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45721       };
45722     } catch (std::exception& e) {
45723       {
45724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45725       };
45726     } catch (...) {
45727       {
45728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45729       };
45730     }
45731   }
45732 }
45733
45734
45735 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
45736   unsigned int jresult ;
45737   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45738   bool result;
45739
45740   arg1 = (Dali::Rect< int > *)jarg1;
45741   {
45742     try {
45743       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
45744     } catch (std::out_of_range& e) {
45745       {
45746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45747       };
45748     } catch (std::exception& e) {
45749       {
45750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45751       };
45752     } catch (...) {
45753       {
45754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45755       };
45756     }
45757   }
45758   jresult = result;
45759   return jresult;
45760 }
45761
45762
45763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
45764   int jresult ;
45765   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45766   int result;
45767
45768   arg1 = (Dali::Rect< int > *)jarg1;
45769   {
45770     try {
45771       result = (int)((Dali::Rect< int > const *)arg1)->Left();
45772     } catch (std::out_of_range& e) {
45773       {
45774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45775       };
45776     } catch (std::exception& e) {
45777       {
45778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45779       };
45780     } catch (...) {
45781       {
45782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45783       };
45784     }
45785   }
45786   jresult = result;
45787   return jresult;
45788 }
45789
45790
45791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
45792   int jresult ;
45793   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45794   int result;
45795
45796   arg1 = (Dali::Rect< int > *)jarg1;
45797   {
45798     try {
45799       result = (int)((Dali::Rect< int > const *)arg1)->Right();
45800     } catch (std::out_of_range& e) {
45801       {
45802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45803       };
45804     } catch (std::exception& e) {
45805       {
45806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45807       };
45808     } catch (...) {
45809       {
45810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45811       };
45812     }
45813   }
45814   jresult = result;
45815   return jresult;
45816 }
45817
45818
45819 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
45820   int jresult ;
45821   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45822   int result;
45823
45824   arg1 = (Dali::Rect< int > *)jarg1;
45825   {
45826     try {
45827       result = (int)((Dali::Rect< int > const *)arg1)->Top();
45828     } catch (std::out_of_range& e) {
45829       {
45830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45831       };
45832     } catch (std::exception& e) {
45833       {
45834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45835       };
45836     } catch (...) {
45837       {
45838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45839       };
45840     }
45841   }
45842   jresult = result;
45843   return jresult;
45844 }
45845
45846
45847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
45848   int jresult ;
45849   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45850   int result;
45851
45852   arg1 = (Dali::Rect< int > *)jarg1;
45853   {
45854     try {
45855       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
45856     } catch (std::out_of_range& e) {
45857       {
45858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45859       };
45860     } catch (std::exception& e) {
45861       {
45862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45863       };
45864     } catch (...) {
45865       {
45866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45867       };
45868     }
45869   }
45870   jresult = result;
45871   return jresult;
45872 }
45873
45874
45875 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
45876   int jresult ;
45877   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45878   int result;
45879
45880   arg1 = (Dali::Rect< int > *)jarg1;
45881   {
45882     try {
45883       result = (int)((Dali::Rect< int > const *)arg1)->Area();
45884     } catch (std::out_of_range& e) {
45885       {
45886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45887       };
45888     } catch (std::exception& e) {
45889       {
45890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45891       };
45892     } catch (...) {
45893       {
45894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45895       };
45896     }
45897   }
45898   jresult = result;
45899   return jresult;
45900 }
45901
45902
45903 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
45904   unsigned int jresult ;
45905   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45906   Dali::Rect< int > *arg2 = 0 ;
45907   bool result;
45908
45909   arg1 = (Dali::Rect< int > *)jarg1;
45910   arg2 = (Dali::Rect< int > *)jarg2;
45911   if (!arg2) {
45912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45913     return 0;
45914   }
45915   {
45916     try {
45917       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
45918     } catch (std::out_of_range& e) {
45919       {
45920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45921       };
45922     } catch (std::exception& e) {
45923       {
45924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45925       };
45926     } catch (...) {
45927       {
45928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45929       };
45930     }
45931   }
45932   jresult = result;
45933   return jresult;
45934 }
45935
45936
45937 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
45938   unsigned int jresult ;
45939   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45940   Dali::Rect< int > *arg2 = 0 ;
45941   bool result;
45942
45943   arg1 = (Dali::Rect< int > *)jarg1;
45944   arg2 = (Dali::Rect< int > *)jarg2;
45945   if (!arg2) {
45946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45947     return 0;
45948   }
45949   {
45950     try {
45951       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
45952     } catch (std::out_of_range& e) {
45953       {
45954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45955       };
45956     } catch (std::exception& e) {
45957       {
45958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45959       };
45960     } catch (...) {
45961       {
45962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45963       };
45964     }
45965   }
45966   jresult = result;
45967   return jresult;
45968 }
45969
45970
45971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
45972   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45973   int arg2 ;
45974
45975   arg1 = (Dali::Rect< int > *)jarg1;
45976   arg2 = (int)jarg2;
45977   if (arg1) (arg1)->x = arg2;
45978 }
45979
45980
45981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
45982   int jresult ;
45983   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45984   int result;
45985
45986   arg1 = (Dali::Rect< int > *)jarg1;
45987   result = (int) ((arg1)->x);
45988   jresult = result;
45989   return jresult;
45990 }
45991
45992
45993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
45994   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45995   int arg2 ;
45996
45997   arg1 = (Dali::Rect< int > *)jarg1;
45998   arg2 = (int)jarg2;
45999   if (arg1) (arg1)->left = arg2;
46000 }
46001
46002
46003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
46004   int jresult ;
46005   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46006   int result;
46007
46008   arg1 = (Dali::Rect< int > *)jarg1;
46009   result = (int) ((arg1)->left);
46010   jresult = result;
46011   return jresult;
46012 }
46013
46014
46015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
46016   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46017   int arg2 ;
46018
46019   arg1 = (Dali::Rect< int > *)jarg1;
46020   arg2 = (int)jarg2;
46021   if (arg1) (arg1)->y = arg2;
46022 }
46023
46024
46025 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
46026   int jresult ;
46027   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46028   int result;
46029
46030   arg1 = (Dali::Rect< int > *)jarg1;
46031   result = (int) ((arg1)->y);
46032   jresult = result;
46033   return jresult;
46034 }
46035
46036
46037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
46038   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46039   int arg2 ;
46040
46041   arg1 = (Dali::Rect< int > *)jarg1;
46042   arg2 = (int)jarg2;
46043   if (arg1) (arg1)->right = arg2;
46044 }
46045
46046
46047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
46048   int jresult ;
46049   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46050   int result;
46051
46052   arg1 = (Dali::Rect< int > *)jarg1;
46053   result = (int) ((arg1)->right);
46054   jresult = result;
46055   return jresult;
46056 }
46057
46058
46059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
46060   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46061   int arg2 ;
46062
46063   arg1 = (Dali::Rect< int > *)jarg1;
46064   arg2 = (int)jarg2;
46065   if (arg1) (arg1)->width = arg2;
46066 }
46067
46068
46069 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
46070   int jresult ;
46071   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46072   int result;
46073
46074   arg1 = (Dali::Rect< int > *)jarg1;
46075   result = (int) ((arg1)->width);
46076   jresult = result;
46077   return jresult;
46078 }
46079
46080
46081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
46082   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46083   int arg2 ;
46084
46085   arg1 = (Dali::Rect< int > *)jarg1;
46086   arg2 = (int)jarg2;
46087   if (arg1) (arg1)->bottom = arg2;
46088 }
46089
46090
46091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
46092   int jresult ;
46093   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46094   int result;
46095
46096   arg1 = (Dali::Rect< int > *)jarg1;
46097   result = (int) ((arg1)->bottom);
46098   jresult = result;
46099   return jresult;
46100 }
46101
46102
46103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
46104   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46105   int arg2 ;
46106
46107   arg1 = (Dali::Rect< int > *)jarg1;
46108   arg2 = (int)jarg2;
46109   if (arg1) (arg1)->height = arg2;
46110 }
46111
46112
46113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
46114   int jresult ;
46115   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46116   int result;
46117
46118   arg1 = (Dali::Rect< int > *)jarg1;
46119   result = (int) ((arg1)->height);
46120   jresult = result;
46121   return jresult;
46122 }
46123
46124
46125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
46126   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46127   int arg2 ;
46128
46129   arg1 = (Dali::Rect< int > *)jarg1;
46130   arg2 = (int)jarg2;
46131   if (arg1) (arg1)->top = arg2;
46132 }
46133
46134
46135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
46136   int jresult ;
46137   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46138   int result;
46139
46140   arg1 = (Dali::Rect< int > *)jarg1;
46141   result = (int) ((arg1)->top);
46142   jresult = result;
46143   return jresult;
46144 }
46145
46146
46147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
46148   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46149
46150   arg1 = (Dali::Rect< int > *)jarg1;
46151   {
46152     try {
46153       delete arg1;
46154     } catch (std::out_of_range& e) {
46155       {
46156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46157       };
46158     } catch (std::exception& e) {
46159       {
46160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46161       };
46162     } catch (...) {
46163       {
46164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46165       };
46166     }
46167   }
46168 }
46169
46170
46171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
46172   void * jresult ;
46173   Dali::Rect< float > *result = 0 ;
46174
46175   {
46176     try {
46177       result = (Dali::Rect< float > *)new Dali::Rect< float >();
46178     } catch (std::out_of_range& e) {
46179       {
46180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46181       };
46182     } catch (std::exception& e) {
46183       {
46184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46185       };
46186     } catch (...) {
46187       {
46188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46189       };
46190     }
46191   }
46192   jresult = (void *)result;
46193   return jresult;
46194 }
46195
46196
46197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
46198   void * jresult ;
46199   float arg1 ;
46200   float arg2 ;
46201   float arg3 ;
46202   float arg4 ;
46203   Dali::Rect< float > *result = 0 ;
46204
46205   arg1 = (float)jarg1;
46206   arg2 = (float)jarg2;
46207   arg3 = (float)jarg3;
46208   arg4 = (float)jarg4;
46209   {
46210     try {
46211       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
46212     } catch (std::out_of_range& e) {
46213       {
46214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46215       };
46216     } catch (std::exception& e) {
46217       {
46218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46219       };
46220     } catch (...) {
46221       {
46222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46223       };
46224     }
46225   }
46226   jresult = (void *)result;
46227   return jresult;
46228 }
46229
46230
46231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
46232   void * jresult ;
46233   Dali::Rect< float > *arg1 = 0 ;
46234   Dali::Rect< float > *result = 0 ;
46235
46236   arg1 = (Dali::Rect< float > *)jarg1;
46237   if (!arg1) {
46238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
46239     return 0;
46240   }
46241   {
46242     try {
46243       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
46244     } catch (std::out_of_range& e) {
46245       {
46246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46247       };
46248     } catch (std::exception& e) {
46249       {
46250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46251       };
46252     } catch (...) {
46253       {
46254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46255       };
46256     }
46257   }
46258   jresult = (void *)result;
46259   return jresult;
46260 }
46261
46262
46263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
46264   void * jresult ;
46265   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46266   Dali::Rect< float > *arg2 = 0 ;
46267   Dali::Rect< float > *result = 0 ;
46268
46269   arg1 = (Dali::Rect< float > *)jarg1;
46270   arg2 = (Dali::Rect< float > *)jarg2;
46271   if (!arg2) {
46272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
46273     return 0;
46274   }
46275   {
46276     try {
46277       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
46278     } catch (std::out_of_range& e) {
46279       {
46280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46281       };
46282     } catch (std::exception& e) {
46283       {
46284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46285       };
46286     } catch (...) {
46287       {
46288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46289       };
46290     }
46291   }
46292   jresult = (void *)result;
46293   return jresult;
46294 }
46295
46296
46297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
46298   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46299   float arg2 ;
46300   float arg3 ;
46301   float arg4 ;
46302   float arg5 ;
46303
46304   arg1 = (Dali::Rect< float > *)jarg1;
46305   arg2 = (float)jarg2;
46306   arg3 = (float)jarg3;
46307   arg4 = (float)jarg4;
46308   arg5 = (float)jarg5;
46309   {
46310     try {
46311       (arg1)->Set(arg2,arg3,arg4,arg5);
46312     } catch (std::out_of_range& e) {
46313       {
46314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46315       };
46316     } catch (std::exception& e) {
46317       {
46318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46319       };
46320     } catch (...) {
46321       {
46322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46323       };
46324     }
46325   }
46326 }
46327
46328
46329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_x_set(void * jarg1, float jarg2) {
46330   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46331   float arg2 ;
46332
46333   arg1 = (Dali::Rect< float > *)jarg1;
46334   arg2 = (float)jarg2;
46335   if (arg1) (arg1)->x = arg2;
46336 }
46337
46338
46339 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_x_get(void * jarg1) {
46340   float jresult ;
46341   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46342   float result;
46343
46344   arg1 = (Dali::Rect< float > *)jarg1;
46345   result = (float) ((arg1)->x);
46346   jresult = result;
46347   return jresult;
46348 }
46349
46350
46351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
46352   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46353   float arg2 ;
46354
46355   arg1 = (Dali::Rect< float > *)jarg1;
46356   arg2 = (float)jarg2;
46357   if (arg1) (arg1)->left = arg2;
46358 }
46359
46360
46361 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
46362   float jresult ;
46363   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46364   float result;
46365
46366   arg1 = (Dali::Rect< float > *)jarg1;
46367   result = (float) ((arg1)->left);
46368   jresult = result;
46369   return jresult;
46370 }
46371
46372
46373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_y_set(void * jarg1, float jarg2) {
46374   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46375   float arg2 ;
46376
46377   arg1 = (Dali::Rect< float > *)jarg1;
46378   arg2 = (float)jarg2;
46379   if (arg1) (arg1)->y = arg2;
46380 }
46381
46382
46383 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_y_get(void * jarg1) {
46384   float jresult ;
46385   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46386   float result;
46387
46388   arg1 = (Dali::Rect< float > *)jarg1;
46389   result = (float) ((arg1)->y);
46390   jresult = result;
46391   return jresult;
46392 }
46393
46394
46395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
46396   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46397   float arg2 ;
46398
46399   arg1 = (Dali::Rect< float > *)jarg1;
46400   arg2 = (float)jarg2;
46401   if (arg1) (arg1)->right = arg2;
46402 }
46403
46404
46405 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
46406   float jresult ;
46407   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46408   float result;
46409
46410   arg1 = (Dali::Rect< float > *)jarg1;
46411   result = (float) ((arg1)->right);
46412   jresult = result;
46413   return jresult;
46414 }
46415
46416
46417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_width_set(void * jarg1, float jarg2) {
46418   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46419   float arg2 ;
46420
46421   arg1 = (Dali::Rect< float > *)jarg1;
46422   arg2 = (float)jarg2;
46423   if (arg1) (arg1)->width = arg2;
46424 }
46425
46426
46427 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_width_get(void * jarg1) {
46428   float jresult ;
46429   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46430   float result;
46431
46432   arg1 = (Dali::Rect< float > *)jarg1;
46433   result = (float) ((arg1)->width);
46434   jresult = result;
46435   return jresult;
46436 }
46437
46438
46439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
46440   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46441   float arg2 ;
46442
46443   arg1 = (Dali::Rect< float > *)jarg1;
46444   arg2 = (float)jarg2;
46445   if (arg1) (arg1)->bottom = arg2;
46446 }
46447
46448
46449 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
46450   float jresult ;
46451   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46452   float result;
46453
46454   arg1 = (Dali::Rect< float > *)jarg1;
46455   result = (float) ((arg1)->bottom);
46456   jresult = result;
46457   return jresult;
46458 }
46459
46460
46461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_height_set(void * jarg1, float jarg2) {
46462   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46463   float arg2 ;
46464
46465   arg1 = (Dali::Rect< float > *)jarg1;
46466   arg2 = (float)jarg2;
46467   if (arg1) (arg1)->height = arg2;
46468 }
46469
46470
46471 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_height_get(void * jarg1) {
46472   float jresult ;
46473   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46474   float result;
46475
46476   arg1 = (Dali::Rect< float > *)jarg1;
46477   result = (float) ((arg1)->height);
46478   jresult = result;
46479   return jresult;
46480 }
46481
46482
46483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
46484   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46485   float arg2 ;
46486
46487   arg1 = (Dali::Rect< float > *)jarg1;
46488   arg2 = (float)jarg2;
46489   if (arg1) (arg1)->top = arg2;
46490 }
46491
46492
46493 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
46494   float jresult ;
46495   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46496   float result;
46497
46498   arg1 = (Dali::Rect< float > *)jarg1;
46499   result = (float) ((arg1)->top);
46500   jresult = result;
46501   return jresult;
46502 }
46503
46504
46505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
46506   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46507
46508   arg1 = (Dali::Rect< float > *)jarg1;
46509   {
46510     try {
46511       delete arg1;
46512     } catch (std::out_of_range& e) {
46513       {
46514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46515       };
46516     } catch (std::exception& e) {
46517       {
46518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46519       };
46520     } catch (...) {
46521       {
46522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46523       };
46524     }
46525   }
46526 }
46527
46528
46529 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
46530   int jresult ;
46531   int result;
46532
46533   result = (int)Dali::Vector< int >::BaseType;
46534   jresult = (int)result;
46535   return jresult;
46536 }
46537
46538
46539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
46540   void * jresult ;
46541   Dali::Vector< int > *result = 0 ;
46542
46543   {
46544     try {
46545       result = (Dali::Vector< int > *)new Dali::Vector< int >();
46546     } catch (std::out_of_range& e) {
46547       {
46548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46549       };
46550     } catch (std::exception& e) {
46551       {
46552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46553       };
46554     } catch (...) {
46555       {
46556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46557       };
46558     }
46559   }
46560   jresult = (void *)result;
46561   return jresult;
46562 }
46563
46564
46565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
46566   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46567
46568   arg1 = (Dali::Vector< int > *)jarg1;
46569   {
46570     try {
46571       delete arg1;
46572     } catch (std::out_of_range& e) {
46573       {
46574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46575       };
46576     } catch (std::exception& e) {
46577       {
46578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46579       };
46580     } catch (...) {
46581       {
46582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46583       };
46584     }
46585   }
46586 }
46587
46588
46589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
46590   void * jresult ;
46591   Dali::Vector< int > *arg1 = 0 ;
46592   Dali::Vector< int > *result = 0 ;
46593
46594   arg1 = (Dali::Vector< int > *)jarg1;
46595   if (!arg1) {
46596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
46597     return 0;
46598   }
46599   {
46600     try {
46601       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
46602     } catch (std::out_of_range& e) {
46603       {
46604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46605       };
46606     } catch (std::exception& e) {
46607       {
46608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46609       };
46610     } catch (...) {
46611       {
46612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46613       };
46614     }
46615   }
46616   jresult = (void *)result;
46617   return jresult;
46618 }
46619
46620
46621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
46622   void * jresult ;
46623   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46624   Dali::Vector< int > *arg2 = 0 ;
46625   Dali::Vector< int > *result = 0 ;
46626
46627   arg1 = (Dali::Vector< int > *)jarg1;
46628   arg2 = (Dali::Vector< int > *)jarg2;
46629   if (!arg2) {
46630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
46631     return 0;
46632   }
46633   {
46634     try {
46635       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
46636     } catch (std::out_of_range& e) {
46637       {
46638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46639       };
46640     } catch (std::exception& e) {
46641       {
46642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46643       };
46644     } catch (...) {
46645       {
46646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46647       };
46648     }
46649   }
46650   jresult = (void *)result;
46651   return jresult;
46652 }
46653
46654
46655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
46656   void * jresult ;
46657   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46658   Dali::Vector< int >::Iterator result;
46659
46660   arg1 = (Dali::Vector< int > *)jarg1;
46661   {
46662     try {
46663       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
46664     } catch (std::out_of_range& e) {
46665       {
46666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46667       };
46668     } catch (std::exception& e) {
46669       {
46670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46671       };
46672     } catch (...) {
46673       {
46674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46675       };
46676     }
46677   }
46678   jresult = (void *)result;
46679   return jresult;
46680 }
46681
46682
46683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
46684   void * jresult ;
46685   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46686   Dali::Vector< int >::Iterator result;
46687
46688   arg1 = (Dali::Vector< int > *)jarg1;
46689   {
46690     try {
46691       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
46692     } catch (std::out_of_range& e) {
46693       {
46694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46695       };
46696     } catch (std::exception& e) {
46697       {
46698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46699       };
46700     } catch (...) {
46701       {
46702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46703       };
46704     }
46705   }
46706   jresult = (void *)result;
46707   return jresult;
46708 }
46709
46710
46711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
46712   void * jresult ;
46713   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46714   Dali::Vector< int >::SizeType arg2 ;
46715   Dali::Vector< int >::ItemType *result = 0 ;
46716
46717   arg1 = (Dali::Vector< int > *)jarg1;
46718   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46719   {
46720     try {
46721       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
46722     } catch (std::out_of_range& e) {
46723       {
46724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46725       };
46726     } catch (std::exception& e) {
46727       {
46728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46729       };
46730     } catch (...) {
46731       {
46732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46733       };
46734     }
46735   }
46736   jresult = (void *)result;
46737   return jresult;
46738 }
46739
46740
46741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
46742   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46743   Dali::Vector< int >::ItemType *arg2 = 0 ;
46744   Dali::Vector< int >::ItemType temp2 ;
46745
46746   arg1 = (Dali::Vector< int > *)jarg1;
46747   temp2 = (Dali::Vector< int >::ItemType)jarg2;
46748   arg2 = &temp2;
46749   {
46750     try {
46751       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
46752     } catch (std::out_of_range& e) {
46753       {
46754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46755       };
46756     } catch (std::exception& e) {
46757       {
46758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46759       };
46760     } catch (...) {
46761       {
46762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46763       };
46764     }
46765   }
46766 }
46767
46768
46769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
46770   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46771   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46772   Dali::Vector< int >::ItemType *arg3 = 0 ;
46773   Dali::Vector< int >::ItemType temp3 ;
46774
46775   arg1 = (Dali::Vector< int > *)jarg1;
46776   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46777   temp3 = (Dali::Vector< int >::ItemType)jarg3;
46778   arg3 = &temp3;
46779   {
46780     try {
46781       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
46782     } catch (std::out_of_range& e) {
46783       {
46784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46785       };
46786     } catch (std::exception& e) {
46787       {
46788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46789       };
46790     } catch (...) {
46791       {
46792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46793       };
46794     }
46795   }
46796 }
46797
46798
46799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
46800   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46801   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46802   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
46803   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
46804
46805   arg1 = (Dali::Vector< int > *)jarg1;
46806   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46807   arg3 = (Dali::Vector< int >::Iterator)jarg3;
46808   arg4 = (Dali::Vector< int >::Iterator)jarg4;
46809   {
46810     try {
46811       (arg1)->Insert(arg2,arg3,arg4);
46812     } catch (std::out_of_range& e) {
46813       {
46814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46815       };
46816     } catch (std::exception& e) {
46817       {
46818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46819       };
46820     } catch (...) {
46821       {
46822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46823       };
46824     }
46825   }
46826 }
46827
46828
46829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
46830   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46831   Dali::Vector< int >::SizeType arg2 ;
46832
46833   arg1 = (Dali::Vector< int > *)jarg1;
46834   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46835   {
46836     try {
46837       (arg1)->Reserve(arg2);
46838     } catch (std::out_of_range& e) {
46839       {
46840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46841       };
46842     } catch (std::exception& e) {
46843       {
46844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46845       };
46846     } catch (...) {
46847       {
46848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46849       };
46850     }
46851   }
46852 }
46853
46854
46855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
46856   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46857   Dali::Vector< int >::SizeType arg2 ;
46858
46859   arg1 = (Dali::Vector< int > *)jarg1;
46860   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46861   {
46862     try {
46863       (arg1)->Resize(arg2);
46864     } catch (std::out_of_range& e) {
46865       {
46866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46867       };
46868     } catch (std::exception& e) {
46869       {
46870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46871       };
46872     } catch (...) {
46873       {
46874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46875       };
46876     }
46877   }
46878 }
46879
46880
46881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
46882   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46883   Dali::Vector< int >::SizeType arg2 ;
46884   Dali::Vector< int >::ItemType *arg3 = 0 ;
46885   Dali::Vector< int >::ItemType temp3 ;
46886
46887   arg1 = (Dali::Vector< int > *)jarg1;
46888   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46889   temp3 = (Dali::Vector< int >::ItemType)jarg3;
46890   arg3 = &temp3;
46891   {
46892     try {
46893       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
46894     } catch (std::out_of_range& e) {
46895       {
46896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46897       };
46898     } catch (std::exception& e) {
46899       {
46900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46901       };
46902     } catch (...) {
46903       {
46904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46905       };
46906     }
46907   }
46908 }
46909
46910
46911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
46912   void * jresult ;
46913   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46914   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46915   Dali::Vector< int >::Iterator result;
46916
46917   arg1 = (Dali::Vector< int > *)jarg1;
46918   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46919   {
46920     try {
46921       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
46922     } catch (std::out_of_range& e) {
46923       {
46924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46925       };
46926     } catch (std::exception& e) {
46927       {
46928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46929       };
46930     } catch (...) {
46931       {
46932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46933       };
46934     }
46935   }
46936   jresult = (void *)result;
46937   return jresult;
46938 }
46939
46940
46941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
46942   void * jresult ;
46943   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46944   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46945   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
46946   Dali::Vector< int >::Iterator result;
46947
46948   arg1 = (Dali::Vector< int > *)jarg1;
46949   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46950   arg3 = (Dali::Vector< int >::Iterator)jarg3;
46951   {
46952     try {
46953       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
46954     } catch (std::out_of_range& e) {
46955       {
46956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46957       };
46958     } catch (std::exception& e) {
46959       {
46960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46961       };
46962     } catch (...) {
46963       {
46964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46965       };
46966     }
46967   }
46968   jresult = (void *)result;
46969   return jresult;
46970 }
46971
46972
46973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
46974   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46975   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46976
46977   arg1 = (Dali::Vector< int > *)jarg1;
46978   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46979   {
46980     try {
46981       (arg1)->Remove(arg2);
46982     } catch (std::out_of_range& e) {
46983       {
46984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46985       };
46986     } catch (std::exception& e) {
46987       {
46988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46989       };
46990     } catch (...) {
46991       {
46992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46993       };
46994     }
46995   }
46996 }
46997
46998
46999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
47000   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47001   Dali::Vector< int > *arg2 = 0 ;
47002
47003   arg1 = (Dali::Vector< int > *)jarg1;
47004   arg2 = (Dali::Vector< int > *)jarg2;
47005   if (!arg2) {
47006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
47007     return ;
47008   }
47009   {
47010     try {
47011       (arg1)->Swap(*arg2);
47012     } catch (std::out_of_range& e) {
47013       {
47014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47015       };
47016     } catch (std::exception& e) {
47017       {
47018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47019       };
47020     } catch (...) {
47021       {
47022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47023       };
47024     }
47025   }
47026 }
47027
47028
47029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
47030   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47031
47032   arg1 = (Dali::Vector< int > *)jarg1;
47033   {
47034     try {
47035       (arg1)->Clear();
47036     } catch (std::out_of_range& e) {
47037       {
47038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47039       };
47040     } catch (std::exception& e) {
47041       {
47042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47043       };
47044     } catch (...) {
47045       {
47046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47047       };
47048     }
47049   }
47050 }
47051
47052
47053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
47054   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47055
47056   arg1 = (Dali::Vector< int > *)jarg1;
47057   {
47058     try {
47059       (arg1)->Release();
47060     } catch (std::out_of_range& e) {
47061       {
47062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47063       };
47064     } catch (std::exception& e) {
47065       {
47066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47067       };
47068     } catch (...) {
47069       {
47070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47071       };
47072     }
47073   }
47074 }
47075
47076
47077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
47078   int jresult ;
47079   int result;
47080
47081   result = (int)Dali::Vector< float >::BaseType;
47082   jresult = (int)result;
47083   return jresult;
47084 }
47085
47086
47087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
47088   void * jresult ;
47089   Dali::Vector< float > *result = 0 ;
47090
47091   {
47092     try {
47093       result = (Dali::Vector< float > *)new Dali::Vector< float >();
47094     } catch (std::out_of_range& e) {
47095       {
47096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47097       };
47098     } catch (std::exception& e) {
47099       {
47100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47101       };
47102     } catch (...) {
47103       {
47104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47105       };
47106     }
47107   }
47108   jresult = (void *)result;
47109   return jresult;
47110 }
47111
47112
47113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
47114   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47115
47116   arg1 = (Dali::Vector< float > *)jarg1;
47117   {
47118     try {
47119       delete arg1;
47120     } catch (std::out_of_range& e) {
47121       {
47122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47123       };
47124     } catch (std::exception& e) {
47125       {
47126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47127       };
47128     } catch (...) {
47129       {
47130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47131       };
47132     }
47133   }
47134 }
47135
47136
47137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
47138   void * jresult ;
47139   Dali::Vector< float > *arg1 = 0 ;
47140   Dali::Vector< float > *result = 0 ;
47141
47142   arg1 = (Dali::Vector< float > *)jarg1;
47143   if (!arg1) {
47144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
47145     return 0;
47146   }
47147   {
47148     try {
47149       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
47150     } catch (std::out_of_range& e) {
47151       {
47152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47153       };
47154     } catch (std::exception& e) {
47155       {
47156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47157       };
47158     } catch (...) {
47159       {
47160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47161       };
47162     }
47163   }
47164   jresult = (void *)result;
47165   return jresult;
47166 }
47167
47168
47169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
47170   void * jresult ;
47171   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47172   Dali::Vector< float > *arg2 = 0 ;
47173   Dali::Vector< float > *result = 0 ;
47174
47175   arg1 = (Dali::Vector< float > *)jarg1;
47176   arg2 = (Dali::Vector< float > *)jarg2;
47177   if (!arg2) {
47178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
47179     return 0;
47180   }
47181   {
47182     try {
47183       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
47184     } catch (std::out_of_range& e) {
47185       {
47186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47187       };
47188     } catch (std::exception& e) {
47189       {
47190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47191       };
47192     } catch (...) {
47193       {
47194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47195       };
47196     }
47197   }
47198   jresult = (void *)result;
47199   return jresult;
47200 }
47201
47202
47203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
47204   void * jresult ;
47205   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47206   Dali::Vector< float >::Iterator result;
47207
47208   arg1 = (Dali::Vector< float > *)jarg1;
47209   {
47210     try {
47211       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
47212     } catch (std::out_of_range& e) {
47213       {
47214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47215       };
47216     } catch (std::exception& e) {
47217       {
47218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47219       };
47220     } catch (...) {
47221       {
47222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47223       };
47224     }
47225   }
47226   jresult = (void *)result;
47227   return jresult;
47228 }
47229
47230
47231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
47232   void * jresult ;
47233   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47234   Dali::Vector< float >::Iterator result;
47235
47236   arg1 = (Dali::Vector< float > *)jarg1;
47237   {
47238     try {
47239       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
47240     } catch (std::out_of_range& e) {
47241       {
47242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47243       };
47244     } catch (std::exception& e) {
47245       {
47246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47247       };
47248     } catch (...) {
47249       {
47250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47251       };
47252     }
47253   }
47254   jresult = (void *)result;
47255   return jresult;
47256 }
47257
47258
47259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47260   void * jresult ;
47261   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47262   Dali::Vector< float >::SizeType arg2 ;
47263   Dali::Vector< float >::ItemType *result = 0 ;
47264
47265   arg1 = (Dali::Vector< float > *)jarg1;
47266   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47267   {
47268     try {
47269       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
47270     } catch (std::out_of_range& e) {
47271       {
47272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47273       };
47274     } catch (std::exception& e) {
47275       {
47276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47277       };
47278     } catch (...) {
47279       {
47280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47281       };
47282     }
47283   }
47284   jresult = (void *)result;
47285   return jresult;
47286 }
47287
47288
47289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
47290   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47291   Dali::Vector< float >::ItemType *arg2 = 0 ;
47292   Dali::Vector< float >::ItemType temp2 ;
47293
47294   arg1 = (Dali::Vector< float > *)jarg1;
47295   temp2 = (Dali::Vector< float >::ItemType)jarg2;
47296   arg2 = &temp2;
47297   {
47298     try {
47299       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
47300     } catch (std::out_of_range& e) {
47301       {
47302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47303       };
47304     } catch (std::exception& e) {
47305       {
47306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47307       };
47308     } catch (...) {
47309       {
47310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47311       };
47312     }
47313   }
47314 }
47315
47316
47317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
47318   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47319   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47320   Dali::Vector< float >::ItemType *arg3 = 0 ;
47321   Dali::Vector< float >::ItemType temp3 ;
47322
47323   arg1 = (Dali::Vector< float > *)jarg1;
47324   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47325   temp3 = (Dali::Vector< float >::ItemType)jarg3;
47326   arg3 = &temp3;
47327   {
47328     try {
47329       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
47330     } catch (std::out_of_range& e) {
47331       {
47332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47333       };
47334     } catch (std::exception& e) {
47335       {
47336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47337       };
47338     } catch (...) {
47339       {
47340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47341       };
47342     }
47343   }
47344 }
47345
47346
47347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
47348   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47349   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47350   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
47351   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
47352
47353   arg1 = (Dali::Vector< float > *)jarg1;
47354   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47355   arg3 = (Dali::Vector< float >::Iterator)jarg3;
47356   arg4 = (Dali::Vector< float >::Iterator)jarg4;
47357   {
47358     try {
47359       (arg1)->Insert(arg2,arg3,arg4);
47360     } catch (std::out_of_range& e) {
47361       {
47362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47363       };
47364     } catch (std::exception& e) {
47365       {
47366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47367       };
47368     } catch (...) {
47369       {
47370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47371       };
47372     }
47373   }
47374 }
47375
47376
47377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
47378   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47379   Dali::Vector< float >::SizeType arg2 ;
47380
47381   arg1 = (Dali::Vector< float > *)jarg1;
47382   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47383   {
47384     try {
47385       (arg1)->Reserve(arg2);
47386     } catch (std::out_of_range& e) {
47387       {
47388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47389       };
47390     } catch (std::exception& e) {
47391       {
47392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47393       };
47394     } catch (...) {
47395       {
47396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47397       };
47398     }
47399   }
47400 }
47401
47402
47403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
47404   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47405   Dali::Vector< float >::SizeType arg2 ;
47406
47407   arg1 = (Dali::Vector< float > *)jarg1;
47408   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47409   {
47410     try {
47411       (arg1)->Resize(arg2);
47412     } catch (std::out_of_range& e) {
47413       {
47414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47415       };
47416     } catch (std::exception& e) {
47417       {
47418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47419       };
47420     } catch (...) {
47421       {
47422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47423       };
47424     }
47425   }
47426 }
47427
47428
47429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
47430   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47431   Dali::Vector< float >::SizeType arg2 ;
47432   Dali::Vector< float >::ItemType *arg3 = 0 ;
47433   Dali::Vector< float >::ItemType temp3 ;
47434
47435   arg1 = (Dali::Vector< float > *)jarg1;
47436   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47437   temp3 = (Dali::Vector< float >::ItemType)jarg3;
47438   arg3 = &temp3;
47439   {
47440     try {
47441       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
47442     } catch (std::out_of_range& e) {
47443       {
47444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47445       };
47446     } catch (std::exception& e) {
47447       {
47448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47449       };
47450     } catch (...) {
47451       {
47452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47453       };
47454     }
47455   }
47456 }
47457
47458
47459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
47460   void * jresult ;
47461   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47462   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47463   Dali::Vector< float >::Iterator result;
47464
47465   arg1 = (Dali::Vector< float > *)jarg1;
47466   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47467   {
47468     try {
47469       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
47470     } catch (std::out_of_range& e) {
47471       {
47472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47473       };
47474     } catch (std::exception& e) {
47475       {
47476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47477       };
47478     } catch (...) {
47479       {
47480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47481       };
47482     }
47483   }
47484   jresult = (void *)result;
47485   return jresult;
47486 }
47487
47488
47489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
47490   void * jresult ;
47491   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47492   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47493   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
47494   Dali::Vector< float >::Iterator result;
47495
47496   arg1 = (Dali::Vector< float > *)jarg1;
47497   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47498   arg3 = (Dali::Vector< float >::Iterator)jarg3;
47499   {
47500     try {
47501       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
47502     } catch (std::out_of_range& e) {
47503       {
47504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47505       };
47506     } catch (std::exception& e) {
47507       {
47508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47509       };
47510     } catch (...) {
47511       {
47512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47513       };
47514     }
47515   }
47516   jresult = (void *)result;
47517   return jresult;
47518 }
47519
47520
47521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
47522   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47523   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47524
47525   arg1 = (Dali::Vector< float > *)jarg1;
47526   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47527   {
47528     try {
47529       (arg1)->Remove(arg2);
47530     } catch (std::out_of_range& e) {
47531       {
47532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47533       };
47534     } catch (std::exception& e) {
47535       {
47536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47537       };
47538     } catch (...) {
47539       {
47540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47541       };
47542     }
47543   }
47544 }
47545
47546
47547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
47548   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47549   Dali::Vector< float > *arg2 = 0 ;
47550
47551   arg1 = (Dali::Vector< float > *)jarg1;
47552   arg2 = (Dali::Vector< float > *)jarg2;
47553   if (!arg2) {
47554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
47555     return ;
47556   }
47557   {
47558     try {
47559       (arg1)->Swap(*arg2);
47560     } catch (std::out_of_range& e) {
47561       {
47562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47563       };
47564     } catch (std::exception& e) {
47565       {
47566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47567       };
47568     } catch (...) {
47569       {
47570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47571       };
47572     }
47573   }
47574 }
47575
47576
47577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
47578   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47579
47580   arg1 = (Dali::Vector< float > *)jarg1;
47581   {
47582     try {
47583       (arg1)->Clear();
47584     } catch (std::out_of_range& e) {
47585       {
47586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47587       };
47588     } catch (std::exception& e) {
47589       {
47590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47591       };
47592     } catch (...) {
47593       {
47594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47595       };
47596     }
47597   }
47598 }
47599
47600
47601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
47602   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47603
47604   arg1 = (Dali::Vector< float > *)jarg1;
47605   {
47606     try {
47607       (arg1)->Release();
47608     } catch (std::out_of_range& e) {
47609       {
47610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47611       };
47612     } catch (std::exception& e) {
47613       {
47614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47615       };
47616     } catch (...) {
47617       {
47618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47619       };
47620     }
47621   }
47622 }
47623
47624
47625 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
47626   int jresult ;
47627   int result;
47628
47629   result = (int)Dali::Vector< unsigned char >::BaseType;
47630   jresult = (int)result;
47631   return jresult;
47632 }
47633
47634
47635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
47636   void * jresult ;
47637   Dali::Vector< unsigned char > *result = 0 ;
47638
47639   {
47640     try {
47641       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
47642     } catch (std::out_of_range& e) {
47643       {
47644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47645       };
47646     } catch (std::exception& e) {
47647       {
47648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47649       };
47650     } catch (...) {
47651       {
47652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47653       };
47654     }
47655   }
47656   jresult = (void *)result;
47657   return jresult;
47658 }
47659
47660
47661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
47662   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47663
47664   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47665   {
47666     try {
47667       delete arg1;
47668     } catch (std::out_of_range& e) {
47669       {
47670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47671       };
47672     } catch (std::exception& e) {
47673       {
47674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47675       };
47676     } catch (...) {
47677       {
47678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47679       };
47680     }
47681   }
47682 }
47683
47684
47685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
47686   void * jresult ;
47687   Dali::Vector< unsigned char > *arg1 = 0 ;
47688   Dali::Vector< unsigned char > *result = 0 ;
47689
47690   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47691   if (!arg1) {
47692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
47693     return 0;
47694   }
47695   {
47696     try {
47697       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
47698     } catch (std::out_of_range& e) {
47699       {
47700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47701       };
47702     } catch (std::exception& e) {
47703       {
47704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47705       };
47706     } catch (...) {
47707       {
47708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47709       };
47710     }
47711   }
47712   jresult = (void *)result;
47713   return jresult;
47714 }
47715
47716
47717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
47718   void * jresult ;
47719   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47720   Dali::Vector< unsigned char > *arg2 = 0 ;
47721   Dali::Vector< unsigned char > *result = 0 ;
47722
47723   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47724   arg2 = (Dali::Vector< unsigned char > *)jarg2;
47725   if (!arg2) {
47726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
47727     return 0;
47728   }
47729   {
47730     try {
47731       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
47732     } catch (std::out_of_range& e) {
47733       {
47734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47735       };
47736     } catch (std::exception& e) {
47737       {
47738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47739       };
47740     } catch (...) {
47741       {
47742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47743       };
47744     }
47745   }
47746   jresult = (void *)result;
47747   return jresult;
47748 }
47749
47750
47751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
47752   void * jresult ;
47753   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47754   Dali::Vector< unsigned char >::Iterator result;
47755
47756   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47757   {
47758     try {
47759       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
47760     } catch (std::out_of_range& e) {
47761       {
47762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47763       };
47764     } catch (std::exception& e) {
47765       {
47766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47767       };
47768     } catch (...) {
47769       {
47770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47771       };
47772     }
47773   }
47774   jresult = (void *)result;
47775   return jresult;
47776 }
47777
47778
47779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
47780   void * jresult ;
47781   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47782   Dali::Vector< unsigned char >::Iterator result;
47783
47784   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47785   {
47786     try {
47787       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
47788     } catch (std::out_of_range& e) {
47789       {
47790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47791       };
47792     } catch (std::exception& e) {
47793       {
47794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47795       };
47796     } catch (...) {
47797       {
47798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47799       };
47800     }
47801   }
47802   jresult = (void *)result;
47803   return jresult;
47804 }
47805
47806
47807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47808   void * jresult ;
47809   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47810   Dali::Vector< unsigned char >::SizeType arg2 ;
47811   Dali::Vector< unsigned char >::ItemType *result = 0 ;
47812
47813   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47814   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47815   {
47816     try {
47817       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
47818     } catch (std::out_of_range& e) {
47819       {
47820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47821       };
47822     } catch (std::exception& e) {
47823       {
47824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47825       };
47826     } catch (...) {
47827       {
47828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47829       };
47830     }
47831   }
47832   jresult = (void *)result;
47833   return jresult;
47834 }
47835
47836
47837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
47838   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47839   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
47840   Dali::Vector< unsigned char >::ItemType temp2 ;
47841
47842   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47843   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
47844   arg2 = &temp2;
47845   {
47846     try {
47847       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
47848     } catch (std::out_of_range& e) {
47849       {
47850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47851       };
47852     } catch (std::exception& e) {
47853       {
47854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47855       };
47856     } catch (...) {
47857       {
47858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47859       };
47860     }
47861   }
47862 }
47863
47864
47865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
47866   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47867   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47868   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
47869   Dali::Vector< unsigned char >::ItemType temp3 ;
47870
47871   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47872   arg2 = jarg2;
47873   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
47874   arg3 = &temp3;
47875   {
47876     try {
47877       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
47878     } catch (std::out_of_range& e) {
47879       {
47880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47881       };
47882     } catch (std::exception& e) {
47883       {
47884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47885       };
47886     } catch (...) {
47887       {
47888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47889       };
47890     }
47891   }
47892
47893
47894 }
47895
47896
47897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
47898   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47899   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47900   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47901   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47902
47903   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47904   arg2 = jarg2;
47905   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
47906   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
47907   {
47908     try {
47909       (arg1)->Insert(arg2,arg3,arg4);
47910     } catch (std::out_of_range& e) {
47911       {
47912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47913       };
47914     } catch (std::exception& e) {
47915       {
47916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47917       };
47918     } catch (...) {
47919       {
47920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47921       };
47922     }
47923   }
47924
47925
47926 }
47927
47928
47929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
47930   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47931   Dali::Vector< unsigned char >::SizeType arg2 ;
47932
47933   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47934   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47935   {
47936     try {
47937       (arg1)->Reserve(arg2);
47938     } catch (std::out_of_range& e) {
47939       {
47940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47941       };
47942     } catch (std::exception& e) {
47943       {
47944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47945       };
47946     } catch (...) {
47947       {
47948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47949       };
47950     }
47951   }
47952 }
47953
47954
47955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
47956   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47957   Dali::Vector< unsigned char >::SizeType arg2 ;
47958
47959   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47960   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47961   {
47962     try {
47963       (arg1)->Resize(arg2);
47964     } catch (std::out_of_range& e) {
47965       {
47966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47967       };
47968     } catch (std::exception& e) {
47969       {
47970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47971       };
47972     } catch (...) {
47973       {
47974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47975       };
47976     }
47977   }
47978 }
47979
47980
47981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
47982   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47983   Dali::Vector< unsigned char >::SizeType arg2 ;
47984   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
47985   Dali::Vector< unsigned char >::ItemType temp3 ;
47986
47987   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47988   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47989   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
47990   arg3 = &temp3;
47991   {
47992     try {
47993       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
47994     } catch (std::out_of_range& e) {
47995       {
47996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47997       };
47998     } catch (std::exception& e) {
47999       {
48000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48001       };
48002     } catch (...) {
48003       {
48004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48005       };
48006     }
48007   }
48008 }
48009
48010
48011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
48012   void * jresult ;
48013   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48014   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48015   Dali::Vector< unsigned char >::Iterator result;
48016
48017   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48018   arg2 = jarg2;
48019   {
48020     try {
48021       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
48022     } catch (std::out_of_range& e) {
48023       {
48024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48025       };
48026     } catch (std::exception& e) {
48027       {
48028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48029       };
48030     } catch (...) {
48031       {
48032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48033       };
48034     }
48035   }
48036   jresult = (void *)result;
48037
48038
48039   return jresult;
48040 }
48041
48042
48043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
48044   void * jresult ;
48045   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48046   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48047   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48048   Dali::Vector< unsigned char >::Iterator result;
48049
48050   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48051   arg2 = jarg2;
48052   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
48053   {
48054     try {
48055       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
48056     } catch (std::out_of_range& e) {
48057       {
48058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48059       };
48060     } catch (std::exception& e) {
48061       {
48062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48063       };
48064     } catch (...) {
48065       {
48066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48067       };
48068     }
48069   }
48070   jresult = (void *)result;
48071
48072
48073   return jresult;
48074 }
48075
48076
48077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
48078   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48079   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48080
48081   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48082   arg2 = jarg2;
48083   {
48084     try {
48085       (arg1)->Remove(arg2);
48086     } catch (std::out_of_range& e) {
48087       {
48088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48089       };
48090     } catch (std::exception& e) {
48091       {
48092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48093       };
48094     } catch (...) {
48095       {
48096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48097       };
48098     }
48099   }
48100
48101
48102 }
48103
48104
48105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
48106   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48107   Dali::Vector< unsigned char > *arg2 = 0 ;
48108
48109   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48110   arg2 = (Dali::Vector< unsigned char > *)jarg2;
48111   if (!arg2) {
48112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
48113     return ;
48114   }
48115   {
48116     try {
48117       (arg1)->Swap(*arg2);
48118     } catch (std::out_of_range& e) {
48119       {
48120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48121       };
48122     } catch (std::exception& e) {
48123       {
48124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48125       };
48126     } catch (...) {
48127       {
48128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48129       };
48130     }
48131   }
48132 }
48133
48134
48135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
48136   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48137
48138   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48139   {
48140     try {
48141       (arg1)->Clear();
48142     } catch (std::out_of_range& e) {
48143       {
48144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48145       };
48146     } catch (std::exception& e) {
48147       {
48148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48149       };
48150     } catch (...) {
48151       {
48152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48153       };
48154     }
48155   }
48156 }
48157
48158
48159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
48160   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48161
48162   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48163   {
48164     try {
48165       (arg1)->Release();
48166     } catch (std::out_of_range& e) {
48167       {
48168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48169       };
48170     } catch (std::exception& e) {
48171       {
48172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48173       };
48174     } catch (...) {
48175       {
48176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48177       };
48178     }
48179   }
48180 }
48181
48182
48183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
48184   int jresult ;
48185   int result;
48186
48187   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
48188   jresult = (int)result;
48189   return jresult;
48190 }
48191
48192
48193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
48194   void * jresult ;
48195   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48196
48197   {
48198     try {
48199       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
48200     } catch (std::out_of_range& e) {
48201       {
48202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48203       };
48204     } catch (std::exception& e) {
48205       {
48206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48207       };
48208     } catch (...) {
48209       {
48210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48211       };
48212     }
48213   }
48214   jresult = (void *)result;
48215   return jresult;
48216 }
48217
48218
48219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
48220   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48221
48222   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48223   {
48224     try {
48225       delete arg1;
48226     } catch (std::out_of_range& e) {
48227       {
48228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48229       };
48230     } catch (std::exception& e) {
48231       {
48232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48233       };
48234     } catch (...) {
48235       {
48236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48237       };
48238     }
48239   }
48240 }
48241
48242
48243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
48244   void * jresult ;
48245   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
48246   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48247
48248   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48249   if (!arg1) {
48250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
48251     return 0;
48252   }
48253   {
48254     try {
48255       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
48256     } catch (std::out_of_range& e) {
48257       {
48258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48259       };
48260     } catch (std::exception& e) {
48261       {
48262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48263       };
48264     } catch (...) {
48265       {
48266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48267       };
48268     }
48269   }
48270   jresult = (void *)result;
48271   return jresult;
48272 }
48273
48274
48275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
48276   void * jresult ;
48277   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48278   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
48279   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48280
48281   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48282   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
48283   if (!arg2) {
48284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
48285     return 0;
48286   }
48287   {
48288     try {
48289       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
48290     } catch (std::out_of_range& e) {
48291       {
48292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48293       };
48294     } catch (std::exception& e) {
48295       {
48296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48297       };
48298     } catch (...) {
48299       {
48300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48301       };
48302     }
48303   }
48304   jresult = (void *)result;
48305   return jresult;
48306 }
48307
48308
48309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
48310   void * jresult ;
48311   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48312   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48313
48314   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48315   {
48316     try {
48317       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
48318     } catch (std::out_of_range& e) {
48319       {
48320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48321       };
48322     } catch (std::exception& e) {
48323       {
48324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48325       };
48326     } catch (...) {
48327       {
48328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48329       };
48330     }
48331   }
48332   jresult = (void *)result;
48333   return jresult;
48334 }
48335
48336
48337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
48338   void * jresult ;
48339   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48340   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48341
48342   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48343   {
48344     try {
48345       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
48346     } catch (std::out_of_range& e) {
48347       {
48348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48349       };
48350     } catch (std::exception& e) {
48351       {
48352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48353       };
48354     } catch (...) {
48355       {
48356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48357       };
48358     }
48359   }
48360   jresult = (void *)result;
48361   return jresult;
48362 }
48363
48364
48365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48366   void * jresult ;
48367   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48368   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48369   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
48370
48371   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48372   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48373   {
48374     try {
48375       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
48376     } catch (std::out_of_range& e) {
48377       {
48378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48379       };
48380     } catch (std::exception& e) {
48381       {
48382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48383       };
48384     } catch (...) {
48385       {
48386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48387       };
48388     }
48389   }
48390   jresult = (void *)result;
48391   return jresult;
48392 }
48393
48394
48395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
48396   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48397   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
48398
48399   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48400   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
48401   if (!arg2) {
48402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48403     return ;
48404   }
48405   {
48406     try {
48407       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
48408     } catch (std::out_of_range& e) {
48409       {
48410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48411       };
48412     } catch (std::exception& e) {
48413       {
48414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48415       };
48416     } catch (...) {
48417       {
48418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48419       };
48420     }
48421   }
48422 }
48423
48424
48425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
48426   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48427   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48428   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
48429
48430   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48431   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48432   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
48433   if (!arg3) {
48434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48435     return ;
48436   }
48437   {
48438     try {
48439       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
48440     } catch (std::out_of_range& e) {
48441       {
48442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48443       };
48444     } catch (std::exception& e) {
48445       {
48446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48447       };
48448     } catch (...) {
48449       {
48450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48451       };
48452     }
48453   }
48454 }
48455
48456
48457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
48458   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48459   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48460   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48461   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48462
48463   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48464   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48465   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
48466   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
48467   {
48468     try {
48469       (arg1)->Insert(arg2,arg3,arg4);
48470     } catch (std::out_of_range& e) {
48471       {
48472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48473       };
48474     } catch (std::exception& e) {
48475       {
48476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48477       };
48478     } catch (...) {
48479       {
48480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48481       };
48482     }
48483   }
48484 }
48485
48486
48487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
48488   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48489   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48490
48491   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48492   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48493   {
48494     try {
48495       (arg1)->Reserve(arg2);
48496     } catch (std::out_of_range& e) {
48497       {
48498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48499       };
48500     } catch (std::exception& e) {
48501       {
48502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48503       };
48504     } catch (...) {
48505       {
48506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48507       };
48508     }
48509   }
48510 }
48511
48512
48513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48514   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48515   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48516
48517   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48518   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48519   {
48520     try {
48521       (arg1)->Resize(arg2);
48522     } catch (std::out_of_range& e) {
48523       {
48524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48525       };
48526     } catch (std::exception& e) {
48527       {
48528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48529       };
48530     } catch (...) {
48531       {
48532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48533       };
48534     }
48535   }
48536 }
48537
48538
48539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
48540   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48541   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48542   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
48543
48544   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48545   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48546   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
48547   if (!arg3) {
48548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48549     return ;
48550   }
48551   {
48552     try {
48553       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
48554     } catch (std::out_of_range& e) {
48555       {
48556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48557       };
48558     } catch (std::exception& e) {
48559       {
48560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48561       };
48562     } catch (...) {
48563       {
48564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48565       };
48566     }
48567   }
48568 }
48569
48570
48571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
48572   void * jresult ;
48573   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48574   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48575   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48576
48577   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48578   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48579   {
48580     try {
48581       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
48582     } catch (std::out_of_range& e) {
48583       {
48584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48585       };
48586     } catch (std::exception& e) {
48587       {
48588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48589       };
48590     } catch (...) {
48591       {
48592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48593       };
48594     }
48595   }
48596   jresult = (void *)result;
48597   return jresult;
48598 }
48599
48600
48601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48602   void * jresult ;
48603   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48604   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48605   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48606   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48607
48608   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48609   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48610   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
48611   {
48612     try {
48613       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
48614     } catch (std::out_of_range& e) {
48615       {
48616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48617       };
48618     } catch (std::exception& e) {
48619       {
48620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48621       };
48622     } catch (...) {
48623       {
48624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48625       };
48626     }
48627   }
48628   jresult = (void *)result;
48629   return jresult;
48630 }
48631
48632
48633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
48634   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48635   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48636
48637   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48638   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48639   {
48640     try {
48641       (arg1)->Remove(arg2);
48642     } catch (std::out_of_range& e) {
48643       {
48644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48645       };
48646     } catch (std::exception& e) {
48647       {
48648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48649       };
48650     } catch (...) {
48651       {
48652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48653       };
48654     }
48655   }
48656 }
48657
48658
48659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
48660   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48661   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
48662
48663   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48664   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
48665   if (!arg2) {
48666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
48667     return ;
48668   }
48669   {
48670     try {
48671       (arg1)->Swap(*arg2);
48672     } catch (std::out_of_range& e) {
48673       {
48674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48675       };
48676     } catch (std::exception& e) {
48677       {
48678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48679       };
48680     } catch (...) {
48681       {
48682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48683       };
48684     }
48685   }
48686 }
48687
48688
48689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
48690   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48691
48692   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48693   {
48694     try {
48695       (arg1)->Clear();
48696     } catch (std::out_of_range& e) {
48697       {
48698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48699       };
48700     } catch (std::exception& e) {
48701       {
48702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48703       };
48704     } catch (...) {
48705       {
48706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48707       };
48708     }
48709   }
48710 }
48711
48712
48713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
48714   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48715
48716   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48717   {
48718     try {
48719       (arg1)->Release();
48720     } catch (std::out_of_range& e) {
48721       {
48722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48723       };
48724     } catch (std::exception& e) {
48725       {
48726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48727       };
48728     } catch (...) {
48729       {
48730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48731       };
48732     }
48733   }
48734 }
48735
48736
48737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
48738   void * jresult ;
48739   Dali::Signal< void () > *result = 0 ;
48740
48741   {
48742     try {
48743       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
48744     } catch (std::out_of_range& e) {
48745       {
48746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48747       };
48748     } catch (std::exception& e) {
48749       {
48750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48751       };
48752     } catch (...) {
48753       {
48754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48755       };
48756     }
48757   }
48758   jresult = (void *)result;
48759   return jresult;
48760 }
48761
48762
48763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
48764   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48765
48766   arg1 = (Dali::Signal< void () > *)jarg1;
48767   {
48768     try {
48769       delete arg1;
48770     } catch (std::out_of_range& e) {
48771       {
48772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48773       };
48774     } catch (std::exception& e) {
48775       {
48776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48777       };
48778     } catch (...) {
48779       {
48780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48781       };
48782     }
48783   }
48784 }
48785
48786
48787 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
48788   unsigned int jresult ;
48789   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48790   bool result;
48791
48792   arg1 = (Dali::Signal< void () > *)jarg1;
48793   {
48794     try {
48795       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
48796     } catch (std::out_of_range& e) {
48797       {
48798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48799       };
48800     } catch (std::exception& e) {
48801       {
48802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48803       };
48804     } catch (...) {
48805       {
48806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48807       };
48808     }
48809   }
48810   jresult = result;
48811   return jresult;
48812 }
48813
48814
48815 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
48816   unsigned long jresult ;
48817   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48818   std::size_t result;
48819
48820   arg1 = (Dali::Signal< void () > *)jarg1;
48821   {
48822     try {
48823       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
48824     } catch (std::out_of_range& e) {
48825       {
48826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48827       };
48828     } catch (std::exception& e) {
48829       {
48830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48831       };
48832     } catch (...) {
48833       {
48834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48835       };
48836     }
48837   }
48838   jresult = (unsigned long)result;
48839   return jresult;
48840 }
48841
48842
48843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
48844   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48845   void (*arg2)() = (void (*)()) 0 ;
48846
48847   arg1 = (Dali::Signal< void () > *)jarg1;
48848   arg2 = (void (*)())jarg2;
48849   {
48850     try {
48851       (arg1)->Connect(arg2);
48852     } catch (std::out_of_range& e) {
48853       {
48854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48855       };
48856     } catch (std::exception& e) {
48857       {
48858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48859       };
48860     } catch (...) {
48861       {
48862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48863       };
48864     }
48865   }
48866 }
48867
48868
48869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
48870   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48871   void (*arg2)() = (void (*)()) 0 ;
48872
48873   arg1 = (Dali::Signal< void () > *)jarg1;
48874   arg2 = (void (*)())jarg2;
48875   {
48876     try {
48877       (arg1)->Disconnect(arg2);
48878     } catch (std::out_of_range& e) {
48879       {
48880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48881       };
48882     } catch (std::exception& e) {
48883       {
48884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48885       };
48886     } catch (...) {
48887       {
48888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48889       };
48890     }
48891   }
48892 }
48893
48894
48895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
48896   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48897   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
48898   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
48899
48900   arg1 = (Dali::Signal< void () > *)jarg1;
48901   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
48902   arg3 = (Dali::FunctorDelegate *)jarg3;
48903   {
48904     try {
48905       (arg1)->Connect(arg2,arg3);
48906     } catch (std::out_of_range& e) {
48907       {
48908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48909       };
48910     } catch (std::exception& e) {
48911       {
48912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48913       };
48914     } catch (...) {
48915       {
48916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48917       };
48918     }
48919   }
48920 }
48921
48922
48923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
48924   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48925
48926   arg1 = (Dali::Signal< void () > *)jarg1;
48927   {
48928     try {
48929       (arg1)->Emit();
48930     } catch (std::out_of_range& e) {
48931       {
48932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48933       };
48934     } catch (std::exception& e) {
48935       {
48936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48937       };
48938     } catch (...) {
48939       {
48940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48941       };
48942     }
48943   }
48944 }
48945
48946
48947 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
48948   unsigned int jresult ;
48949   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48950   bool result;
48951
48952   arg1 = (Dali::Signal< void (float) > *)jarg1;
48953   {
48954     try {
48955       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
48956     } catch (std::out_of_range& e) {
48957       {
48958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48959       };
48960     } catch (std::exception& e) {
48961       {
48962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48963       };
48964     } catch (...) {
48965       {
48966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48967       };
48968     }
48969   }
48970   jresult = result;
48971   return jresult;
48972 }
48973
48974
48975 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
48976   unsigned long jresult ;
48977   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48978   std::size_t result;
48979
48980   arg1 = (Dali::Signal< void (float) > *)jarg1;
48981   {
48982     try {
48983       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
48984     } catch (std::out_of_range& e) {
48985       {
48986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48987       };
48988     } catch (std::exception& e) {
48989       {
48990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48991       };
48992     } catch (...) {
48993       {
48994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48995       };
48996     }
48997   }
48998   jresult = (unsigned long)result;
48999   return jresult;
49000 }
49001
49002
49003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
49004   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49005   void (*arg2)(float) = (void (*)(float)) 0 ;
49006
49007   arg1 = (Dali::Signal< void (float) > *)jarg1;
49008   arg2 = (void (*)(float))jarg2;
49009   {
49010     try {
49011       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
49012     } catch (std::out_of_range& e) {
49013       {
49014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49015       };
49016     } catch (std::exception& e) {
49017       {
49018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49019       };
49020     } catch (...) {
49021       {
49022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49023       };
49024     }
49025   }
49026 }
49027
49028
49029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
49030   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49031   void (*arg2)(float) = (void (*)(float)) 0 ;
49032
49033   arg1 = (Dali::Signal< void (float) > *)jarg1;
49034   arg2 = (void (*)(float))jarg2;
49035   {
49036     try {
49037       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
49038     } catch (std::out_of_range& e) {
49039       {
49040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49041       };
49042     } catch (std::exception& e) {
49043       {
49044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49045       };
49046     } catch (...) {
49047       {
49048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49049       };
49050     }
49051   }
49052 }
49053
49054
49055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
49056   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49057   float arg2 ;
49058
49059   arg1 = (Dali::Signal< void (float) > *)jarg1;
49060   arg2 = (float)jarg2;
49061   {
49062     try {
49063       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
49064     } catch (std::out_of_range& e) {
49065       {
49066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49067       };
49068     } catch (std::exception& e) {
49069       {
49070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49071       };
49072     } catch (...) {
49073       {
49074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49075       };
49076     }
49077   }
49078 }
49079
49080
49081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
49082   void * jresult ;
49083   Dali::Signal< void (float) > *result = 0 ;
49084
49085   {
49086     try {
49087       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
49088     } catch (std::out_of_range& e) {
49089       {
49090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49091       };
49092     } catch (std::exception& e) {
49093       {
49094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49095       };
49096     } catch (...) {
49097       {
49098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49099       };
49100     }
49101   }
49102   jresult = (void *)result;
49103   return jresult;
49104 }
49105
49106
49107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
49108   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49109
49110   arg1 = (Dali::Signal< void (float) > *)jarg1;
49111   {
49112     try {
49113       delete arg1;
49114     } catch (std::out_of_range& e) {
49115       {
49116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49117       };
49118     } catch (std::exception& e) {
49119       {
49120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49121       };
49122     } catch (...) {
49123       {
49124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49125       };
49126     }
49127   }
49128 }
49129
49130
49131 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
49132   unsigned int jresult ;
49133   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49134   bool result;
49135
49136   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49137   {
49138     try {
49139       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
49140     } catch (std::out_of_range& e) {
49141       {
49142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49143       };
49144     } catch (std::exception& e) {
49145       {
49146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49147       };
49148     } catch (...) {
49149       {
49150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49151       };
49152     }
49153   }
49154   jresult = result;
49155   return jresult;
49156 }
49157
49158
49159 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
49160   unsigned long jresult ;
49161   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49162   std::size_t result;
49163
49164   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49165   {
49166     try {
49167       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
49168     } catch (std::out_of_range& e) {
49169       {
49170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49171       };
49172     } catch (std::exception& e) {
49173       {
49174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49175       };
49176     } catch (...) {
49177       {
49178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49179       };
49180     }
49181   }
49182   jresult = (unsigned long)result;
49183   return jresult;
49184 }
49185
49186
49187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
49188   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49189   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
49190
49191   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49192   arg2 = (void (*)(Dali::BaseHandle))jarg2;
49193   {
49194     try {
49195       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
49196     } catch (std::out_of_range& e) {
49197       {
49198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49199       };
49200     } catch (std::exception& e) {
49201       {
49202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49203       };
49204     } catch (...) {
49205       {
49206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49207       };
49208     }
49209   }
49210 }
49211
49212
49213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
49214   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49215   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
49216
49217   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49218   arg2 = (void (*)(Dali::BaseHandle))jarg2;
49219   {
49220     try {
49221       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
49222     } catch (std::out_of_range& e) {
49223       {
49224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49225       };
49226     } catch (std::exception& e) {
49227       {
49228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49229       };
49230     } catch (...) {
49231       {
49232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49233       };
49234     }
49235   }
49236 }
49237
49238
49239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
49240   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49241   Dali::BaseHandle arg2 ;
49242   Dali::BaseHandle *argp2 ;
49243
49244   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49245   argp2 = (Dali::BaseHandle *)jarg2;
49246   if (!argp2) {
49247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
49248     return ;
49249   }
49250   arg2 = *argp2;
49251   {
49252     try {
49253       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
49254     } catch (std::out_of_range& e) {
49255       {
49256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49257       };
49258     } catch (std::exception& e) {
49259       {
49260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49261       };
49262     } catch (...) {
49263       {
49264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49265       };
49266     }
49267   }
49268 }
49269
49270
49271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
49272   void * jresult ;
49273   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
49274
49275   {
49276     try {
49277       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
49278     } catch (std::out_of_range& e) {
49279       {
49280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49281       };
49282     } catch (std::exception& e) {
49283       {
49284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49285       };
49286     } catch (...) {
49287       {
49288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49289       };
49290     }
49291   }
49292   jresult = (void *)result;
49293   return jresult;
49294 }
49295
49296
49297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
49298   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49299
49300   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49301   {
49302     try {
49303       delete arg1;
49304     } catch (std::out_of_range& e) {
49305       {
49306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49307       };
49308     } catch (std::exception& e) {
49309       {
49310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49311       };
49312     } catch (...) {
49313       {
49314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49315       };
49316     }
49317   }
49318 }
49319
49320
49321 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
49322   unsigned int jresult ;
49323   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49324   bool result;
49325
49326   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49327   {
49328     try {
49329       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
49330     } catch (std::out_of_range& e) {
49331       {
49332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49333       };
49334     } catch (std::exception& e) {
49335       {
49336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49337       };
49338     } catch (...) {
49339       {
49340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49341       };
49342     }
49343   }
49344   jresult = result;
49345   return jresult;
49346 }
49347
49348
49349 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
49350   unsigned long jresult ;
49351   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49352   std::size_t result;
49353
49354   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49355   {
49356     try {
49357       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
49358     } catch (std::out_of_range& e) {
49359       {
49360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49361       };
49362     } catch (std::exception& e) {
49363       {
49364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49365       };
49366     } catch (...) {
49367       {
49368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49369       };
49370     }
49371   }
49372   jresult = (unsigned long)result;
49373   return jresult;
49374 }
49375
49376
49377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
49378   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49379   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
49380
49381   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49382   arg2 = (void (*)(Dali::RefObject const *))jarg2;
49383   {
49384     try {
49385       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
49386     } catch (std::out_of_range& e) {
49387       {
49388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49389       };
49390     } catch (std::exception& e) {
49391       {
49392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49393       };
49394     } catch (...) {
49395       {
49396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49397       };
49398     }
49399   }
49400 }
49401
49402
49403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
49404   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49405   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
49406
49407   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49408   arg2 = (void (*)(Dali::RefObject const *))jarg2;
49409   {
49410     try {
49411       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
49412     } catch (std::out_of_range& e) {
49413       {
49414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49415       };
49416     } catch (std::exception& e) {
49417       {
49418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49419       };
49420     } catch (...) {
49421       {
49422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49423       };
49424     }
49425   }
49426 }
49427
49428
49429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
49430   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49431   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
49432
49433   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49434   arg2 = (Dali::RefObject *)jarg2;
49435   {
49436     try {
49437       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
49438     } catch (std::out_of_range& e) {
49439       {
49440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49441       };
49442     } catch (std::exception& e) {
49443       {
49444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49445       };
49446     } catch (...) {
49447       {
49448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49449       };
49450     }
49451   }
49452 }
49453
49454
49455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
49456   void * jresult ;
49457   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
49458
49459   {
49460     try {
49461       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
49462     } catch (std::out_of_range& e) {
49463       {
49464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49465       };
49466     } catch (std::exception& e) {
49467       {
49468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49469       };
49470     } catch (...) {
49471       {
49472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49473       };
49474     }
49475   }
49476   jresult = (void *)result;
49477   return jresult;
49478 }
49479
49480
49481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
49482   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49483
49484   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49485   {
49486     try {
49487       delete arg1;
49488     } catch (std::out_of_range& e) {
49489       {
49490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49491       };
49492     } catch (std::exception& e) {
49493       {
49494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49495       };
49496     } catch (...) {
49497       {
49498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49499       };
49500     }
49501   }
49502 }
49503
49504
49505 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
49506   unsigned int jresult ;
49507   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49508   bool result;
49509
49510   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49511   {
49512     try {
49513       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
49514     } catch (std::out_of_range& e) {
49515       {
49516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49517       };
49518     } catch (std::exception& e) {
49519       {
49520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49521       };
49522     } catch (...) {
49523       {
49524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49525       };
49526     }
49527   }
49528   jresult = result;
49529   return jresult;
49530 }
49531
49532
49533 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
49534   unsigned long jresult ;
49535   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49536   std::size_t result;
49537
49538   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49539   {
49540     try {
49541       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
49542     } catch (std::out_of_range& e) {
49543       {
49544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49545       };
49546     } catch (std::exception& e) {
49547       {
49548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49549       };
49550     } catch (...) {
49551       {
49552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49553       };
49554     }
49555   }
49556   jresult = (unsigned long)result;
49557   return jresult;
49558 }
49559
49560
49561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
49562   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49563   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
49564
49565   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49566   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
49567   {
49568     try {
49569       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
49570     } catch (std::out_of_range& e) {
49571       {
49572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49573       };
49574     } catch (std::exception& e) {
49575       {
49576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49577       };
49578     } catch (...) {
49579       {
49580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49581       };
49582     }
49583   }
49584 }
49585
49586
49587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
49588   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49589   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
49590
49591   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49592   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
49593   {
49594     try {
49595       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
49596     } catch (std::out_of_range& e) {
49597       {
49598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49599       };
49600     } catch (std::exception& e) {
49601       {
49602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49603       };
49604     } catch (...) {
49605       {
49606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49607       };
49608     }
49609   }
49610 }
49611
49612
49613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
49614   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49615   Dali::PropertyNotification *arg2 = 0 ;
49616
49617   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49618   arg2 = (Dali::PropertyNotification *)jarg2;
49619   if (!arg2) {
49620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
49621     return ;
49622   }
49623   {
49624     try {
49625       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
49626     } catch (std::out_of_range& e) {
49627       {
49628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49629       };
49630     } catch (std::exception& e) {
49631       {
49632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49633       };
49634     } catch (...) {
49635       {
49636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49637       };
49638     }
49639   }
49640 }
49641
49642
49643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
49644   void * jresult ;
49645   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
49646
49647   {
49648     try {
49649       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
49650     } catch (std::out_of_range& e) {
49651       {
49652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49653       };
49654     } catch (std::exception& e) {
49655       {
49656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49657       };
49658     } catch (...) {
49659       {
49660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49661       };
49662     }
49663   }
49664   jresult = (void *)result;
49665   return jresult;
49666 }
49667
49668
49669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
49670   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49671
49672   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49673   {
49674     try {
49675       delete arg1;
49676     } catch (std::out_of_range& e) {
49677       {
49678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49679       };
49680     } catch (std::exception& e) {
49681       {
49682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49683       };
49684     } catch (...) {
49685       {
49686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49687       };
49688     }
49689   }
49690 }
49691
49692
49693 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
49694   unsigned int jresult ;
49695   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49696   bool result;
49697
49698   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49699   {
49700     try {
49701       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
49702     } catch (std::out_of_range& e) {
49703       {
49704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49705       };
49706     } catch (std::exception& e) {
49707       {
49708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49709       };
49710     } catch (...) {
49711       {
49712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49713       };
49714     }
49715   }
49716   jresult = result;
49717   return jresult;
49718 }
49719
49720
49721 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
49722   unsigned long jresult ;
49723   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49724   std::size_t result;
49725
49726   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49727   {
49728     try {
49729       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
49730     } catch (std::out_of_range& e) {
49731       {
49732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49733       };
49734     } catch (std::exception& e) {
49735       {
49736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49737       };
49738     } catch (...) {
49739       {
49740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49741       };
49742     }
49743   }
49744   jresult = (unsigned long)result;
49745   return jresult;
49746 }
49747
49748
49749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
49750   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49751   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
49752
49753   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49754   arg2 = (void (*)(Dali::Image))jarg2;
49755   {
49756     try {
49757       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
49758     } catch (std::out_of_range& e) {
49759       {
49760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49761       };
49762     } catch (std::exception& e) {
49763       {
49764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49765       };
49766     } catch (...) {
49767       {
49768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49769       };
49770     }
49771   }
49772 }
49773
49774
49775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
49776   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49777   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
49778
49779   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49780   arg2 = (void (*)(Dali::Image))jarg2;
49781   {
49782     try {
49783       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
49784     } catch (std::out_of_range& e) {
49785       {
49786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49787       };
49788     } catch (std::exception& e) {
49789       {
49790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49791       };
49792     } catch (...) {
49793       {
49794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49795       };
49796     }
49797   }
49798 }
49799
49800
49801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
49802   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49803   Dali::Image arg2 ;
49804   Dali::Image *argp2 ;
49805
49806   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49807   argp2 = (Dali::Image *)jarg2;
49808   if (!argp2) {
49809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
49810     return ;
49811   }
49812   arg2 = *argp2;
49813   {
49814     try {
49815       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
49816     } catch (std::out_of_range& e) {
49817       {
49818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49819       };
49820     } catch (std::exception& e) {
49821       {
49822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49823       };
49824     } catch (...) {
49825       {
49826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49827       };
49828     }
49829   }
49830 }
49831
49832
49833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
49834   void * jresult ;
49835   Dali::Signal< void (Dali::Image) > *result = 0 ;
49836
49837   {
49838     try {
49839       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
49840     } catch (std::out_of_range& e) {
49841       {
49842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49843       };
49844     } catch (std::exception& e) {
49845       {
49846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49847       };
49848     } catch (...) {
49849       {
49850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49851       };
49852     }
49853   }
49854   jresult = (void *)result;
49855   return jresult;
49856 }
49857
49858
49859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
49860   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49861
49862   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49863   {
49864     try {
49865       delete arg1;
49866     } catch (std::out_of_range& e) {
49867       {
49868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49869       };
49870     } catch (std::exception& e) {
49871       {
49872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49873       };
49874     } catch (...) {
49875       {
49876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49877       };
49878     }
49879   }
49880 }
49881
49882
49883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
49884   void * jresult ;
49885   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
49886
49887   {
49888     try {
49889       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
49890     } catch (std::out_of_range& e) {
49891       {
49892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49893       };
49894     } catch (std::exception& e) {
49895       {
49896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49897       };
49898     } catch (...) {
49899       {
49900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49901       };
49902     }
49903   }
49904   jresult = (void *)result;
49905   return jresult;
49906 }
49907
49908
49909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
49910   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
49911
49912   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
49913   {
49914     try {
49915       delete arg1;
49916     } catch (std::out_of_range& e) {
49917       {
49918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49919       };
49920     } catch (std::exception& e) {
49921       {
49922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49923       };
49924     } catch (...) {
49925       {
49926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49927       };
49928     }
49929   }
49930 }
49931
49932
49933 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
49934   unsigned int jresult ;
49935   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49936   bool result;
49937
49938   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49939   {
49940     try {
49941       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);
49942     } catch (std::out_of_range& e) {
49943       {
49944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49945       };
49946     } catch (std::exception& e) {
49947       {
49948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49949       };
49950     } catch (...) {
49951       {
49952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49953       };
49954     }
49955   }
49956   jresult = result;
49957   return jresult;
49958 }
49959
49960
49961 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
49962   unsigned long jresult ;
49963   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49964   std::size_t result;
49965
49966   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49967   {
49968     try {
49969       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);
49970     } catch (std::out_of_range& e) {
49971       {
49972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49973       };
49974     } catch (std::exception& e) {
49975       {
49976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49977       };
49978     } catch (...) {
49979       {
49980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49981       };
49982     }
49983   }
49984   jresult = (unsigned long)result;
49985   return jresult;
49986 }
49987
49988
49989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
49990   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49991   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
49992
49993   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49994   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
49995   {
49996     try {
49997       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49998     } catch (std::out_of_range& e) {
49999       {
50000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50001       };
50002     } catch (std::exception& e) {
50003       {
50004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50005       };
50006     } catch (...) {
50007       {
50008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50009       };
50010     }
50011   }
50012 }
50013
50014
50015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
50016   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50017   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
50018
50019   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50020   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
50021   {
50022     try {
50023       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50024     } catch (std::out_of_range& e) {
50025       {
50026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50027       };
50028     } catch (std::exception& e) {
50029       {
50030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50031       };
50032     } catch (...) {
50033       {
50034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50035       };
50036     }
50037   }
50038 }
50039
50040
50041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50042   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50043   Dali::Actor arg2 ;
50044   Dali::LongPressGesture *arg3 = 0 ;
50045   Dali::Actor *argp2 ;
50046
50047   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50048   argp2 = (Dali::Actor *)jarg2;
50049   if (!argp2) {
50050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50051     return ;
50052   }
50053   arg2 = *argp2;
50054   arg3 = (Dali::LongPressGesture *)jarg3;
50055   if (!arg3) {
50056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
50057     return ;
50058   }
50059   {
50060     try {
50061       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
50062     } catch (std::out_of_range& e) {
50063       {
50064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50065       };
50066     } catch (std::exception& e) {
50067       {
50068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50069       };
50070     } catch (...) {
50071       {
50072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50073       };
50074     }
50075   }
50076 }
50077
50078
50079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
50080   void * jresult ;
50081   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
50082
50083   {
50084     try {
50085       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
50086     } catch (std::out_of_range& e) {
50087       {
50088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50089       };
50090     } catch (std::exception& e) {
50091       {
50092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50093       };
50094     } catch (...) {
50095       {
50096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50097       };
50098     }
50099   }
50100   jresult = (void *)result;
50101   return jresult;
50102 }
50103
50104
50105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
50106   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50107
50108   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50109   {
50110     try {
50111       delete arg1;
50112     } catch (std::out_of_range& e) {
50113       {
50114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50115       };
50116     } catch (std::exception& e) {
50117       {
50118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50119       };
50120     } catch (...) {
50121       {
50122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50123       };
50124     }
50125   }
50126 }
50127
50128
50129 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
50130   unsigned int jresult ;
50131   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50132   bool result;
50133
50134   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50135   {
50136     try {
50137       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);
50138     } catch (std::out_of_range& e) {
50139       {
50140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50141       };
50142     } catch (std::exception& e) {
50143       {
50144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50145       };
50146     } catch (...) {
50147       {
50148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50149       };
50150     }
50151   }
50152   jresult = result;
50153   return jresult;
50154 }
50155
50156
50157 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
50158   unsigned long jresult ;
50159   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50160   std::size_t result;
50161
50162   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50163   {
50164     try {
50165       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);
50166     } catch (std::out_of_range& e) {
50167       {
50168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50169       };
50170     } catch (std::exception& e) {
50171       {
50172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50173       };
50174     } catch (...) {
50175       {
50176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50177       };
50178     }
50179   }
50180   jresult = (unsigned long)result;
50181   return jresult;
50182 }
50183
50184
50185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
50186   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50187   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
50188
50189   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50190   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
50191   {
50192     try {
50193       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50194     } catch (std::out_of_range& e) {
50195       {
50196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50197       };
50198     } catch (std::exception& e) {
50199       {
50200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50201       };
50202     } catch (...) {
50203       {
50204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50205       };
50206     }
50207   }
50208 }
50209
50210
50211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
50212   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50213   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
50214
50215   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50216   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
50217   {
50218     try {
50219       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50220     } catch (std::out_of_range& e) {
50221       {
50222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50223       };
50224     } catch (std::exception& e) {
50225       {
50226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50227       };
50228     } catch (...) {
50229       {
50230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50231       };
50232     }
50233   }
50234 }
50235
50236
50237 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50238   unsigned int jresult ;
50239   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50240   Dali::Actor arg2 ;
50241   Dali::TouchData *arg3 = 0 ;
50242   Dali::Actor *argp2 ;
50243   bool result;
50244
50245   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50246   argp2 = (Dali::Actor *)jarg2;
50247   if (!argp2) {
50248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50249     return 0;
50250   }
50251   arg2 = *argp2;
50252   arg3 = (Dali::TouchData *)jarg3;
50253   if (!arg3) {
50254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
50255     return 0;
50256   }
50257   {
50258     try {
50259       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
50260     } catch (std::out_of_range& e) {
50261       {
50262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50263       };
50264     } catch (std::exception& e) {
50265       {
50266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50267       };
50268     } catch (...) {
50269       {
50270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50271       };
50272     }
50273   }
50274   jresult = result;
50275   return jresult;
50276 }
50277
50278
50279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
50280   void * jresult ;
50281   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
50282
50283   {
50284     try {
50285       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
50286     } catch (std::out_of_range& e) {
50287       {
50288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50289       };
50290     } catch (std::exception& e) {
50291       {
50292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50293       };
50294     } catch (...) {
50295       {
50296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50297       };
50298     }
50299   }
50300   jresult = (void *)result;
50301   return jresult;
50302 }
50303
50304
50305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
50306   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50307
50308   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50309   {
50310     try {
50311       delete arg1;
50312     } catch (std::out_of_range& e) {
50313       {
50314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50315       };
50316     } catch (std::exception& e) {
50317       {
50318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50319       };
50320     } catch (...) {
50321       {
50322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50323       };
50324     }
50325   }
50326 }
50327
50328
50329 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
50330   unsigned int jresult ;
50331   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50332   bool result;
50333
50334   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50335   {
50336     try {
50337       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);
50338     } catch (std::out_of_range& e) {
50339       {
50340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50341       };
50342     } catch (std::exception& e) {
50343       {
50344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50345       };
50346     } catch (...) {
50347       {
50348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50349       };
50350     }
50351   }
50352   jresult = result;
50353   return jresult;
50354 }
50355
50356
50357 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
50358   unsigned long jresult ;
50359   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50360   std::size_t result;
50361
50362   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50363   {
50364     try {
50365       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);
50366     } catch (std::out_of_range& e) {
50367       {
50368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50369       };
50370     } catch (std::exception& e) {
50371       {
50372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50373       };
50374     } catch (...) {
50375       {
50376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50377       };
50378     }
50379   }
50380   jresult = (unsigned long)result;
50381   return jresult;
50382 }
50383
50384
50385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
50386   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50387   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
50388
50389   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50390   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
50391   {
50392     try {
50393       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50394     } catch (std::out_of_range& e) {
50395       {
50396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50397       };
50398     } catch (std::exception& e) {
50399       {
50400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50401       };
50402     } catch (...) {
50403       {
50404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50405       };
50406     }
50407   }
50408 }
50409
50410
50411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
50412   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50413   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
50414
50415   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50416   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
50417   {
50418     try {
50419       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50420     } catch (std::out_of_range& e) {
50421       {
50422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50423       };
50424     } catch (std::exception& e) {
50425       {
50426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50427       };
50428     } catch (...) {
50429       {
50430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50431       };
50432     }
50433   }
50434 }
50435
50436
50437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50438   unsigned int jresult ;
50439   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50440   Dali::Actor arg2 ;
50441   Dali::HoverEvent *arg3 = 0 ;
50442   Dali::Actor *argp2 ;
50443   bool result;
50444
50445   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50446   argp2 = (Dali::Actor *)jarg2;
50447   if (!argp2) {
50448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50449     return 0;
50450   }
50451   arg2 = *argp2;
50452   arg3 = (Dali::HoverEvent *)jarg3;
50453   if (!arg3) {
50454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
50455     return 0;
50456   }
50457   {
50458     try {
50459       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
50460     } catch (std::out_of_range& e) {
50461       {
50462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50463       };
50464     } catch (std::exception& e) {
50465       {
50466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50467       };
50468     } catch (...) {
50469       {
50470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50471       };
50472     }
50473   }
50474   jresult = result;
50475   return jresult;
50476 }
50477
50478
50479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
50480   void * jresult ;
50481   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
50482
50483   {
50484     try {
50485       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
50486     } catch (std::out_of_range& e) {
50487       {
50488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50489       };
50490     } catch (std::exception& e) {
50491       {
50492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50493       };
50494     } catch (...) {
50495       {
50496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50497       };
50498     }
50499   }
50500   jresult = (void *)result;
50501   return jresult;
50502 }
50503
50504
50505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
50506   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50507
50508   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50509   {
50510     try {
50511       delete arg1;
50512     } catch (std::out_of_range& e) {
50513       {
50514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50515       };
50516     } catch (std::exception& e) {
50517       {
50518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50519       };
50520     } catch (...) {
50521       {
50522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50523       };
50524     }
50525   }
50526 }
50527
50528
50529 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
50530   unsigned int jresult ;
50531   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50532   bool result;
50533
50534   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50535   {
50536     try {
50537       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);
50538     } catch (std::out_of_range& e) {
50539       {
50540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50541       };
50542     } catch (std::exception& e) {
50543       {
50544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50545       };
50546     } catch (...) {
50547       {
50548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50549       };
50550     }
50551   }
50552   jresult = result;
50553   return jresult;
50554 }
50555
50556
50557 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
50558   unsigned long jresult ;
50559   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50560   std::size_t result;
50561
50562   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50563   {
50564     try {
50565       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);
50566     } catch (std::out_of_range& e) {
50567       {
50568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50569       };
50570     } catch (std::exception& e) {
50571       {
50572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50573       };
50574     } catch (...) {
50575       {
50576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50577       };
50578     }
50579   }
50580   jresult = (unsigned long)result;
50581   return jresult;
50582 }
50583
50584
50585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
50586   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50587   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
50588
50589   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50590   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
50591   {
50592     try {
50593       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50594     } catch (std::out_of_range& e) {
50595       {
50596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50597       };
50598     } catch (std::exception& e) {
50599       {
50600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50601       };
50602     } catch (...) {
50603       {
50604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50605       };
50606     }
50607   }
50608 }
50609
50610
50611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
50612   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50613   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
50614
50615   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50616   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
50617   {
50618     try {
50619       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50620     } catch (std::out_of_range& e) {
50621       {
50622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50623       };
50624     } catch (std::exception& e) {
50625       {
50626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50627       };
50628     } catch (...) {
50629       {
50630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50631       };
50632     }
50633   }
50634 }
50635
50636
50637 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50638   unsigned int jresult ;
50639   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50640   Dali::Actor arg2 ;
50641   Dali::WheelEvent *arg3 = 0 ;
50642   Dali::Actor *argp2 ;
50643   bool result;
50644
50645   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50646   argp2 = (Dali::Actor *)jarg2;
50647   if (!argp2) {
50648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50649     return 0;
50650   }
50651   arg2 = *argp2;
50652   arg3 = (Dali::WheelEvent *)jarg3;
50653   if (!arg3) {
50654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
50655     return 0;
50656   }
50657   {
50658     try {
50659       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
50660     } catch (std::out_of_range& e) {
50661       {
50662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50663       };
50664     } catch (std::exception& e) {
50665       {
50666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50667       };
50668     } catch (...) {
50669       {
50670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50671       };
50672     }
50673   }
50674   jresult = result;
50675   return jresult;
50676 }
50677
50678
50679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
50680   void * jresult ;
50681   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
50682
50683   {
50684     try {
50685       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
50686     } catch (std::out_of_range& e) {
50687       {
50688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50689       };
50690     } catch (std::exception& e) {
50691       {
50692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50693       };
50694     } catch (...) {
50695       {
50696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50697       };
50698     }
50699   }
50700   jresult = (void *)result;
50701   return jresult;
50702 }
50703
50704
50705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
50706   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50707
50708   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50709   {
50710     try {
50711       delete arg1;
50712     } catch (std::out_of_range& e) {
50713       {
50714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50715       };
50716     } catch (std::exception& e) {
50717       {
50718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50719       };
50720     } catch (...) {
50721       {
50722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50723       };
50724     }
50725   }
50726 }
50727
50728
50729 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
50730   unsigned int jresult ;
50731   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50732   bool result;
50733
50734   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50735   {
50736     try {
50737       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
50738     } catch (std::out_of_range& e) {
50739       {
50740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50741       };
50742     } catch (std::exception& e) {
50743       {
50744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50745       };
50746     } catch (...) {
50747       {
50748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50749       };
50750     }
50751   }
50752   jresult = result;
50753   return jresult;
50754 }
50755
50756
50757 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
50758   unsigned long jresult ;
50759   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50760   std::size_t result;
50761
50762   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50763   {
50764     try {
50765       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
50766     } catch (std::out_of_range& e) {
50767       {
50768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50769       };
50770     } catch (std::exception& e) {
50771       {
50772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50773       };
50774     } catch (...) {
50775       {
50776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50777       };
50778     }
50779   }
50780   jresult = (unsigned long)result;
50781   return jresult;
50782 }
50783
50784
50785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
50786   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50787   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
50788
50789   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50790   arg2 = (void (*)(Dali::Actor))jarg2;
50791   {
50792     try {
50793       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
50794     } catch (std::out_of_range& e) {
50795       {
50796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50797       };
50798     } catch (std::exception& e) {
50799       {
50800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50801       };
50802     } catch (...) {
50803       {
50804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50805       };
50806     }
50807   }
50808 }
50809
50810
50811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
50812   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50813   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
50814
50815   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50816   arg2 = (void (*)(Dali::Actor))jarg2;
50817   {
50818     try {
50819       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
50820     } catch (std::out_of_range& e) {
50821       {
50822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50823       };
50824     } catch (std::exception& e) {
50825       {
50826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50827       };
50828     } catch (...) {
50829       {
50830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50831       };
50832     }
50833   }
50834 }
50835
50836
50837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
50838   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50839   Dali::Actor arg2 ;
50840   Dali::Actor *argp2 ;
50841
50842   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50843   argp2 = (Dali::Actor *)jarg2;
50844   if (!argp2) {
50845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50846     return ;
50847   }
50848   arg2 = *argp2;
50849   {
50850     try {
50851       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
50852     } catch (std::out_of_range& e) {
50853       {
50854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50855       };
50856     } catch (std::exception& e) {
50857       {
50858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50859       };
50860     } catch (...) {
50861       {
50862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50863       };
50864     }
50865   }
50866 }
50867
50868
50869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
50870   void * jresult ;
50871   Dali::Signal< void (Dali::Actor) > *result = 0 ;
50872
50873   {
50874     try {
50875       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
50876     } catch (std::out_of_range& e) {
50877       {
50878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50879       };
50880     } catch (std::exception& e) {
50881       {
50882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50883       };
50884     } catch (...) {
50885       {
50886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50887       };
50888     }
50889   }
50890   jresult = (void *)result;
50891   return jresult;
50892 }
50893
50894
50895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
50896   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50897
50898   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50899   {
50900     try {
50901       delete arg1;
50902     } catch (std::out_of_range& e) {
50903       {
50904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50905       };
50906     } catch (std::exception& e) {
50907       {
50908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50909       };
50910     } catch (...) {
50911       {
50912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50913       };
50914     }
50915   }
50916 }
50917
50918
50919 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
50920   unsigned int jresult ;
50921   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50922   bool result;
50923
50924   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50925   {
50926     try {
50927       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
50928     } catch (std::out_of_range& e) {
50929       {
50930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50931       };
50932     } catch (std::exception& e) {
50933       {
50934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50935       };
50936     } catch (...) {
50937       {
50938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50939       };
50940     }
50941   }
50942   jresult = result;
50943   return jresult;
50944 }
50945
50946
50947 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
50948   unsigned long jresult ;
50949   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50950   std::size_t result;
50951
50952   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50953   {
50954     try {
50955       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
50956     } catch (std::out_of_range& e) {
50957       {
50958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50959       };
50960     } catch (std::exception& e) {
50961       {
50962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50963       };
50964     } catch (...) {
50965       {
50966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50967       };
50968     }
50969   }
50970   jresult = (unsigned long)result;
50971   return jresult;
50972 }
50973
50974
50975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
50976   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50977   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
50978
50979   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50980   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
50981   {
50982     try {
50983       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50984     } catch (std::out_of_range& e) {
50985       {
50986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50987       };
50988     } catch (std::exception& e) {
50989       {
50990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50991       };
50992     } catch (...) {
50993       {
50994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50995       };
50996     }
50997   }
50998 }
50999
51000
51001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
51002   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51003   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
51004
51005   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51006   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
51007   {
51008     try {
51009       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51010     } catch (std::out_of_range& e) {
51011       {
51012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51013       };
51014     } catch (std::exception& e) {
51015       {
51016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51017       };
51018     } catch (...) {
51019       {
51020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51021       };
51022     }
51023   }
51024 }
51025
51026
51027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
51028   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51029   Dali::KeyEvent *arg2 = 0 ;
51030
51031   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51032   arg2 = (Dali::KeyEvent *)jarg2;
51033   if (!arg2) {
51034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
51035     return ;
51036   }
51037   {
51038     try {
51039       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
51040     } catch (std::out_of_range& e) {
51041       {
51042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51043       };
51044     } catch (std::exception& e) {
51045       {
51046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51047       };
51048     } catch (...) {
51049       {
51050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51051       };
51052     }
51053   }
51054 }
51055
51056
51057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
51058   void * jresult ;
51059   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
51060
51061   {
51062     try {
51063       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
51064     } catch (std::out_of_range& e) {
51065       {
51066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51067       };
51068     } catch (std::exception& e) {
51069       {
51070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51071       };
51072     } catch (...) {
51073       {
51074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51075       };
51076     }
51077   }
51078   jresult = (void *)result;
51079   return jresult;
51080 }
51081
51082
51083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
51084   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51085
51086   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51087   {
51088     try {
51089       delete arg1;
51090     } catch (std::out_of_range& e) {
51091       {
51092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51093       };
51094     } catch (std::exception& e) {
51095       {
51096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51097       };
51098     } catch (...) {
51099       {
51100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51101       };
51102     }
51103   }
51104 }
51105
51106
51107 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
51108   unsigned int jresult ;
51109   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51110   bool result;
51111
51112   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51113   {
51114     try {
51115       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
51116     } catch (std::out_of_range& e) {
51117       {
51118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51119       };
51120     } catch (std::exception& e) {
51121       {
51122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51123       };
51124     } catch (...) {
51125       {
51126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51127       };
51128     }
51129   }
51130   jresult = result;
51131   return jresult;
51132 }
51133
51134
51135 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
51136   unsigned long jresult ;
51137   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51138   std::size_t result;
51139
51140   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51141   {
51142     try {
51143       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
51144     } catch (std::out_of_range& e) {
51145       {
51146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51147       };
51148     } catch (std::exception& e) {
51149       {
51150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51151       };
51152     } catch (...) {
51153       {
51154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51155       };
51156     }
51157   }
51158   jresult = (unsigned long)result;
51159   return jresult;
51160 }
51161
51162
51163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
51164   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51165   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
51166
51167   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51168   arg2 = (void (*)(Dali::TouchData const &))jarg2;
51169   {
51170     try {
51171       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51172     } catch (std::out_of_range& e) {
51173       {
51174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51175       };
51176     } catch (std::exception& e) {
51177       {
51178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51179       };
51180     } catch (...) {
51181       {
51182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51183       };
51184     }
51185   }
51186 }
51187
51188
51189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
51190   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51191   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
51192
51193   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51194   arg2 = (void (*)(Dali::TouchData const &))jarg2;
51195   {
51196     try {
51197       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51198     } catch (std::out_of_range& e) {
51199       {
51200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51201       };
51202     } catch (std::exception& e) {
51203       {
51204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51205       };
51206     } catch (...) {
51207       {
51208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51209       };
51210     }
51211   }
51212 }
51213
51214
51215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
51216   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51217   Dali::TouchData *arg2 = 0 ;
51218
51219   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51220   arg2 = (Dali::TouchData *)jarg2;
51221   if (!arg2) {
51222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
51223     return ;
51224   }
51225   {
51226     try {
51227       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
51228     } catch (std::out_of_range& e) {
51229       {
51230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51231       };
51232     } catch (std::exception& e) {
51233       {
51234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51235       };
51236     } catch (...) {
51237       {
51238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51239       };
51240     }
51241   }
51242 }
51243
51244
51245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
51246   void * jresult ;
51247   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
51248
51249   {
51250     try {
51251       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
51252     } catch (std::out_of_range& e) {
51253       {
51254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51255       };
51256     } catch (std::exception& e) {
51257       {
51258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51259       };
51260     } catch (...) {
51261       {
51262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51263       };
51264     }
51265   }
51266   jresult = (void *)result;
51267   return jresult;
51268 }
51269
51270
51271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
51272   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51273
51274   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51275   {
51276     try {
51277       delete arg1;
51278     } catch (std::out_of_range& e) {
51279       {
51280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51281       };
51282     } catch (std::exception& e) {
51283       {
51284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51285       };
51286     } catch (...) {
51287       {
51288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51289       };
51290     }
51291   }
51292 }
51293
51294
51295 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
51296   unsigned int jresult ;
51297   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51298   bool result;
51299
51300   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51301   {
51302     try {
51303       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
51304     } catch (std::out_of_range& e) {
51305       {
51306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51307       };
51308     } catch (std::exception& e) {
51309       {
51310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51311       };
51312     } catch (...) {
51313       {
51314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51315       };
51316     }
51317   }
51318   jresult = result;
51319   return jresult;
51320 }
51321
51322
51323 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
51324   unsigned long jresult ;
51325   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51326   std::size_t result;
51327
51328   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51329   {
51330     try {
51331       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
51332     } catch (std::out_of_range& e) {
51333       {
51334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51335       };
51336     } catch (std::exception& e) {
51337       {
51338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51339       };
51340     } catch (...) {
51341       {
51342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51343       };
51344     }
51345   }
51346   jresult = (unsigned long)result;
51347   return jresult;
51348 }
51349
51350
51351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
51352   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51353   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
51354
51355   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51356   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
51357   {
51358     try {
51359       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51360     } catch (std::out_of_range& e) {
51361       {
51362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51363       };
51364     } catch (std::exception& e) {
51365       {
51366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51367       };
51368     } catch (...) {
51369       {
51370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51371       };
51372     }
51373   }
51374 }
51375
51376
51377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
51378   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51379   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
51380
51381   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51382   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
51383   {
51384     try {
51385       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51386     } catch (std::out_of_range& e) {
51387       {
51388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51389       };
51390     } catch (std::exception& e) {
51391       {
51392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51393       };
51394     } catch (...) {
51395       {
51396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51397       };
51398     }
51399   }
51400 }
51401
51402
51403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
51404   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51405   Dali::WheelEvent *arg2 = 0 ;
51406
51407   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51408   arg2 = (Dali::WheelEvent *)jarg2;
51409   if (!arg2) {
51410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
51411     return ;
51412   }
51413   {
51414     try {
51415       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
51416     } catch (std::out_of_range& e) {
51417       {
51418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51419       };
51420     } catch (std::exception& e) {
51421       {
51422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51423       };
51424     } catch (...) {
51425       {
51426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51427       };
51428     }
51429   }
51430 }
51431
51432
51433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
51434   void * jresult ;
51435   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
51436
51437   {
51438     try {
51439       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
51440     } catch (std::out_of_range& e) {
51441       {
51442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51443       };
51444     } catch (std::exception& e) {
51445       {
51446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51447       };
51448     } catch (...) {
51449       {
51450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51451       };
51452     }
51453   }
51454   jresult = (void *)result;
51455   return jresult;
51456 }
51457
51458
51459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
51460   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51461
51462   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51463   {
51464     try {
51465       delete arg1;
51466     } catch (std::out_of_range& e) {
51467       {
51468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51469       };
51470     } catch (std::exception& e) {
51471       {
51472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51473       };
51474     } catch (...) {
51475       {
51476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51477       };
51478     }
51479   }
51480 }
51481
51482
51483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
51484   void * jresult ;
51485   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51486
51487   {
51488     try {
51489       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
51490     } catch (std::out_of_range& e) {
51491       {
51492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51493       };
51494     } catch (std::exception& e) {
51495       {
51496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51497       };
51498     } catch (...) {
51499       {
51500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51501       };
51502     }
51503   }
51504   jresult = (void *)result;
51505   return jresult;
51506 }
51507
51508
51509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
51510   void * jresult ;
51511   Dali::Radian arg1 ;
51512   Dali::Radian arg2 ;
51513   Dali::Radian *argp1 ;
51514   Dali::Radian *argp2 ;
51515   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51516
51517   argp1 = (Dali::Radian *)jarg1;
51518   if (!argp1) {
51519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
51520     return 0;
51521   }
51522   arg1 = *argp1;
51523   argp2 = (Dali::Radian *)jarg2;
51524   if (!argp2) {
51525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
51526     return 0;
51527   }
51528   arg2 = *argp2;
51529   {
51530     try {
51531       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
51532     } catch (std::out_of_range& e) {
51533       {
51534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51535       };
51536     } catch (std::exception& e) {
51537       {
51538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51539       };
51540     } catch (...) {
51541       {
51542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51543       };
51544     }
51545   }
51546   jresult = (void *)result;
51547   return jresult;
51548 }
51549
51550
51551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
51552   void * jresult ;
51553   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
51554   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51555
51556   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51557   if (!arg1) {
51558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
51559     return 0;
51560   }
51561   {
51562     try {
51563       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
51564     } catch (std::out_of_range& e) {
51565       {
51566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51567       };
51568     } catch (std::exception& e) {
51569       {
51570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51571       };
51572     } catch (...) {
51573       {
51574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51575       };
51576     }
51577   }
51578   jresult = (void *)result;
51579   return jresult;
51580 }
51581
51582
51583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
51584   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51585   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
51586
51587   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51588   arg2 = (Dali::Radian *)jarg2;
51589   if (arg1) (arg1)->first = *arg2;
51590 }
51591
51592
51593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
51594   void * jresult ;
51595   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51596   Dali::Radian *result = 0 ;
51597
51598   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51599   result = (Dali::Radian *)& ((arg1)->first);
51600   jresult = (void *)result;
51601   return jresult;
51602 }
51603
51604
51605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
51606   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51607   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
51608
51609   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51610   arg2 = (Dali::Radian *)jarg2;
51611   if (arg1) (arg1)->second = *arg2;
51612 }
51613
51614
51615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
51616   void * jresult ;
51617   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51618   Dali::Radian *result = 0 ;
51619
51620   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51621   result = (Dali::Radian *)& ((arg1)->second);
51622   jresult = (void *)result;
51623   return jresult;
51624 }
51625
51626
51627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
51628   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51629
51630   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51631   {
51632     try {
51633       delete arg1;
51634     } catch (std::out_of_range& e) {
51635       {
51636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51637       };
51638     } catch (std::exception& e) {
51639       {
51640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51641       };
51642     } catch (...) {
51643       {
51644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51645       };
51646     }
51647   }
51648 }
51649
51650
51651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
51652   unsigned int jresult ;
51653   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51654   bool result;
51655
51656   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51657   {
51658     try {
51659       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);
51660     } catch (std::out_of_range& e) {
51661       {
51662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51663       };
51664     } catch (std::exception& e) {
51665       {
51666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51667       };
51668     } catch (...) {
51669       {
51670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51671       };
51672     }
51673   }
51674   jresult = result;
51675   return jresult;
51676 }
51677
51678
51679 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51680   unsigned long jresult ;
51681   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51682   std::size_t result;
51683
51684   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51685   {
51686     try {
51687       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);
51688     } catch (std::out_of_range& e) {
51689       {
51690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51691       };
51692     } catch (std::exception& e) {
51693       {
51694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51695       };
51696     } catch (...) {
51697       {
51698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51699       };
51700     }
51701   }
51702   jresult = (unsigned long)result;
51703   return jresult;
51704 }
51705
51706
51707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51708   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51709   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
51710
51711   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51712   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
51713   {
51714     try {
51715       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51716     } catch (std::out_of_range& e) {
51717       {
51718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51719       };
51720     } catch (std::exception& e) {
51721       {
51722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51723       };
51724     } catch (...) {
51725       {
51726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51727       };
51728     }
51729   }
51730 }
51731
51732
51733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51734   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51735   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
51736
51737   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51738   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
51739   {
51740     try {
51741       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51742     } catch (std::out_of_range& e) {
51743       {
51744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51745       };
51746     } catch (std::exception& e) {
51747       {
51748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51749       };
51750     } catch (...) {
51751       {
51752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51753       };
51754     }
51755   }
51756 }
51757
51758
51759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51760   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51761   Dali::Actor arg2 ;
51762   Dali::PanGesture *arg3 = 0 ;
51763   Dali::Actor *argp2 ;
51764
51765   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51766   argp2 = (Dali::Actor *)jarg2;
51767   if (!argp2) {
51768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51769     return ;
51770   }
51771   arg2 = *argp2;
51772   arg3 = (Dali::PanGesture *)jarg3;
51773   if (!arg3) {
51774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
51775     return ;
51776   }
51777   {
51778     try {
51779       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
51780     } catch (std::out_of_range& e) {
51781       {
51782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51783       };
51784     } catch (std::exception& e) {
51785       {
51786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51787       };
51788     } catch (...) {
51789       {
51790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51791       };
51792     }
51793   }
51794 }
51795
51796
51797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
51798   void * jresult ;
51799   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
51800
51801   {
51802     try {
51803       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
51804     } catch (std::out_of_range& e) {
51805       {
51806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51807       };
51808     } catch (std::exception& e) {
51809       {
51810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51811       };
51812     } catch (...) {
51813       {
51814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51815       };
51816     }
51817   }
51818   jresult = (void *)result;
51819   return jresult;
51820 }
51821
51822
51823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
51824   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51825
51826   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51827   {
51828     try {
51829       delete arg1;
51830     } catch (std::out_of_range& e) {
51831       {
51832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51833       };
51834     } catch (std::exception& e) {
51835       {
51836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51837       };
51838     } catch (...) {
51839       {
51840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51841       };
51842     }
51843   }
51844 }
51845
51846
51847 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
51848   unsigned int jresult ;
51849   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51850   bool result;
51851
51852   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51853   {
51854     try {
51855       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);
51856     } catch (std::out_of_range& e) {
51857       {
51858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51859       };
51860     } catch (std::exception& e) {
51861       {
51862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51863       };
51864     } catch (...) {
51865       {
51866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51867       };
51868     }
51869   }
51870   jresult = result;
51871   return jresult;
51872 }
51873
51874
51875 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51876   unsigned long jresult ;
51877   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51878   std::size_t result;
51879
51880   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51881   {
51882     try {
51883       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);
51884     } catch (std::out_of_range& e) {
51885       {
51886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51887       };
51888     } catch (std::exception& e) {
51889       {
51890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51891       };
51892     } catch (...) {
51893       {
51894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51895       };
51896     }
51897   }
51898   jresult = (unsigned long)result;
51899   return jresult;
51900 }
51901
51902
51903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51904   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51905   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
51906
51907   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51908   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
51909   {
51910     try {
51911       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51912     } catch (std::out_of_range& e) {
51913       {
51914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51915       };
51916     } catch (std::exception& e) {
51917       {
51918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51919       };
51920     } catch (...) {
51921       {
51922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51923       };
51924     }
51925   }
51926 }
51927
51928
51929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51930   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51931   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
51932
51933   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51934   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
51935   {
51936     try {
51937       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51938     } catch (std::out_of_range& e) {
51939       {
51940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51941       };
51942     } catch (std::exception& e) {
51943       {
51944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51945       };
51946     } catch (...) {
51947       {
51948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51949       };
51950     }
51951   }
51952 }
51953
51954
51955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51956   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51957   Dali::Actor arg2 ;
51958   Dali::PinchGesture *arg3 = 0 ;
51959   Dali::Actor *argp2 ;
51960
51961   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51962   argp2 = (Dali::Actor *)jarg2;
51963   if (!argp2) {
51964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51965     return ;
51966   }
51967   arg2 = *argp2;
51968   arg3 = (Dali::PinchGesture *)jarg3;
51969   if (!arg3) {
51970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
51971     return ;
51972   }
51973   {
51974     try {
51975       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
51976     } catch (std::out_of_range& e) {
51977       {
51978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51979       };
51980     } catch (std::exception& e) {
51981       {
51982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51983       };
51984     } catch (...) {
51985       {
51986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51987       };
51988     }
51989   }
51990 }
51991
51992
51993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
51994   void * jresult ;
51995   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
51996
51997   {
51998     try {
51999       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
52000     } catch (std::out_of_range& e) {
52001       {
52002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52003       };
52004     } catch (std::exception& e) {
52005       {
52006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52007       };
52008     } catch (...) {
52009       {
52010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52011       };
52012     }
52013   }
52014   jresult = (void *)result;
52015   return jresult;
52016 }
52017
52018
52019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
52020   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
52021
52022   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
52023   {
52024     try {
52025       delete arg1;
52026     } catch (std::out_of_range& e) {
52027       {
52028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52029       };
52030     } catch (std::exception& e) {
52031       {
52032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52033       };
52034     } catch (...) {
52035       {
52036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52037       };
52038     }
52039   }
52040 }
52041
52042
52043 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
52044   unsigned int jresult ;
52045   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52046   bool result;
52047
52048   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52049   {
52050     try {
52051       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);
52052     } catch (std::out_of_range& e) {
52053       {
52054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52055       };
52056     } catch (std::exception& e) {
52057       {
52058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52059       };
52060     } catch (...) {
52061       {
52062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52063       };
52064     }
52065   }
52066   jresult = result;
52067   return jresult;
52068 }
52069
52070
52071 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
52072   unsigned long jresult ;
52073   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52074   std::size_t result;
52075
52076   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52077   {
52078     try {
52079       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);
52080     } catch (std::out_of_range& e) {
52081       {
52082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52083       };
52084     } catch (std::exception& e) {
52085       {
52086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52087       };
52088     } catch (...) {
52089       {
52090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52091       };
52092     }
52093   }
52094   jresult = (unsigned long)result;
52095   return jresult;
52096 }
52097
52098
52099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
52100   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52101   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
52102
52103   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52104   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
52105   {
52106     try {
52107       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52108     } catch (std::out_of_range& e) {
52109       {
52110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52111       };
52112     } catch (std::exception& e) {
52113       {
52114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52115       };
52116     } catch (...) {
52117       {
52118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52119       };
52120     }
52121   }
52122 }
52123
52124
52125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
52126   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52127   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
52128
52129   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52130   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
52131   {
52132     try {
52133       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52134     } catch (std::out_of_range& e) {
52135       {
52136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52137       };
52138     } catch (std::exception& e) {
52139       {
52140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52141       };
52142     } catch (...) {
52143       {
52144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52145       };
52146     }
52147   }
52148 }
52149
52150
52151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52152   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52153   Dali::Actor arg2 ;
52154   Dali::TapGesture *arg3 = 0 ;
52155   Dali::Actor *argp2 ;
52156
52157   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52158   argp2 = (Dali::Actor *)jarg2;
52159   if (!argp2) {
52160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52161     return ;
52162   }
52163   arg2 = *argp2;
52164   arg3 = (Dali::TapGesture *)jarg3;
52165   if (!arg3) {
52166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
52167     return ;
52168   }
52169   {
52170     try {
52171       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
52172     } catch (std::out_of_range& e) {
52173       {
52174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52175       };
52176     } catch (std::exception& e) {
52177       {
52178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52179       };
52180     } catch (...) {
52181       {
52182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52183       };
52184     }
52185   }
52186 }
52187
52188
52189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
52190   void * jresult ;
52191   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
52192
52193   {
52194     try {
52195       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
52196     } catch (std::out_of_range& e) {
52197       {
52198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52199       };
52200     } catch (std::exception& e) {
52201       {
52202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52203       };
52204     } catch (...) {
52205       {
52206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52207       };
52208     }
52209   }
52210   jresult = (void *)result;
52211   return jresult;
52212 }
52213
52214
52215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
52216   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52217
52218   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52219   {
52220     try {
52221       delete arg1;
52222     } catch (std::out_of_range& e) {
52223       {
52224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52225       };
52226     } catch (std::exception& e) {
52227       {
52228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52229       };
52230     } catch (...) {
52231       {
52232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52233       };
52234     }
52235   }
52236 }
52237
52238
52239 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AnimationSignal_Empty(void * jarg1) {
52240   unsigned int jresult ;
52241   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52242   bool result;
52243
52244   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52245   {
52246     try {
52247       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Animation &) > const *)arg1);
52248     } catch (std::out_of_range& e) {
52249       {
52250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52251       };
52252     } catch (std::exception& e) {
52253       {
52254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52255       };
52256     } catch (...) {
52257       {
52258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52259       };
52260     }
52261   }
52262   jresult = result;
52263   return jresult;
52264 }
52265
52266
52267 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AnimationSignal_GetConnectionCount(void * jarg1) {
52268   unsigned long jresult ;
52269   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52270   std::size_t result;
52271
52272   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52273   {
52274     try {
52275       result = Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Animation &) > const *)arg1);
52276     } catch (std::out_of_range& e) {
52277       {
52278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52279       };
52280     } catch (std::exception& e) {
52281       {
52282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52283       };
52284     } catch (...) {
52285       {
52286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52287       };
52288     }
52289   }
52290   jresult = (unsigned long)result;
52291   return jresult;
52292 }
52293
52294
52295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Connect(void * jarg1, void * jarg2) {
52296   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52297   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
52298
52299   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52300   arg2 = (void (*)(Dali::Animation &))jarg2;
52301   {
52302     try {
52303       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(arg1,arg2);
52304     } catch (std::out_of_range& e) {
52305       {
52306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52307       };
52308     } catch (std::exception& e) {
52309       {
52310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52311       };
52312     } catch (...) {
52313       {
52314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52315       };
52316     }
52317   }
52318 }
52319
52320
52321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Disconnect(void * jarg1, void * jarg2) {
52322   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52323   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
52324
52325   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52326   arg2 = (void (*)(Dali::Animation &))jarg2;
52327   {
52328     try {
52329       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(arg1,arg2);
52330     } catch (std::out_of_range& e) {
52331       {
52332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52333       };
52334     } catch (std::exception& e) {
52335       {
52336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52337       };
52338     } catch (...) {
52339       {
52340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52341       };
52342     }
52343   }
52344 }
52345
52346
52347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Emit(void * jarg1, void * jarg2) {
52348   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52349   Dali::Animation *arg2 = 0 ;
52350
52351   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52352   arg2 = (Dali::Animation *)jarg2;
52353   if (!arg2) {
52354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
52355     return ;
52356   }
52357   {
52358     try {
52359       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(arg1,*arg2);
52360     } catch (std::out_of_range& e) {
52361       {
52362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52363       };
52364     } catch (std::exception& e) {
52365       {
52366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52367       };
52368     } catch (...) {
52369       {
52370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52371       };
52372     }
52373   }
52374 }
52375
52376
52377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimationSignal() {
52378   void * jresult ;
52379   Dali::Signal< void (Dali::Animation &) > *result = 0 ;
52380
52381   {
52382     try {
52383       result = (Dali::Signal< void (Dali::Animation &) > *)new Dali::Signal< void (Dali::Animation &) >();
52384     } catch (std::out_of_range& e) {
52385       {
52386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52387       };
52388     } catch (std::exception& e) {
52389       {
52390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52391       };
52392     } catch (...) {
52393       {
52394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52395       };
52396     }
52397   }
52398   jresult = (void *)result;
52399   return jresult;
52400 }
52401
52402
52403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimationSignal(void * jarg1) {
52404   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52405
52406   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52407   {
52408     try {
52409       delete arg1;
52410     } catch (std::out_of_range& e) {
52411       {
52412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52413       };
52414     } catch (std::exception& e) {
52415       {
52416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52417       };
52418     } catch (...) {
52419       {
52420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52421       };
52422     }
52423   }
52424 }
52425
52426
52427 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
52428   unsigned int jresult ;
52429   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52430   bool result;
52431
52432   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52433   {
52434     try {
52435       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
52436     } catch (std::out_of_range& e) {
52437       {
52438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52439       };
52440     } catch (std::exception& e) {
52441       {
52442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52443       };
52444     } catch (...) {
52445       {
52446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52447       };
52448     }
52449   }
52450   jresult = result;
52451   return jresult;
52452 }
52453
52454
52455 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
52456   unsigned long jresult ;
52457   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52458   std::size_t result;
52459
52460   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52461   {
52462     try {
52463       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
52464     } catch (std::out_of_range& e) {
52465       {
52466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52467       };
52468     } catch (std::exception& e) {
52469       {
52470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52471       };
52472     } catch (...) {
52473       {
52474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52475       };
52476     }
52477   }
52478   jresult = (unsigned long)result;
52479   return jresult;
52480 }
52481
52482
52483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
52484   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52485   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
52486
52487   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52488   arg2 = (void (*)(Dali::ResourceImage))jarg2;
52489   {
52490     try {
52491       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
52492     } catch (std::out_of_range& e) {
52493       {
52494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52495       };
52496     } catch (std::exception& e) {
52497       {
52498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52499       };
52500     } catch (...) {
52501       {
52502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52503       };
52504     }
52505   }
52506 }
52507
52508
52509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
52510   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52511   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
52512
52513   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52514   arg2 = (void (*)(Dali::ResourceImage))jarg2;
52515   {
52516     try {
52517       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
52518     } catch (std::out_of_range& e) {
52519       {
52520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52521       };
52522     } catch (std::exception& e) {
52523       {
52524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52525       };
52526     } catch (...) {
52527       {
52528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52529       };
52530     }
52531   }
52532 }
52533
52534
52535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
52536   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52537   Dali::ResourceImage arg2 ;
52538   Dali::ResourceImage *argp2 ;
52539
52540   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52541   argp2 = (Dali::ResourceImage *)jarg2;
52542   if (!argp2) {
52543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
52544     return ;
52545   }
52546   arg2 = *argp2;
52547   {
52548     try {
52549       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
52550     } catch (std::out_of_range& e) {
52551       {
52552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52553       };
52554     } catch (std::exception& e) {
52555       {
52556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52557       };
52558     } catch (...) {
52559       {
52560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52561       };
52562     }
52563   }
52564 }
52565
52566
52567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
52568   void * jresult ;
52569   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
52570
52571   {
52572     try {
52573       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
52574     } catch (std::out_of_range& e) {
52575       {
52576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52577       };
52578     } catch (std::exception& e) {
52579       {
52580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52581       };
52582     } catch (...) {
52583       {
52584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52585       };
52586     }
52587   }
52588   jresult = (void *)result;
52589   return jresult;
52590 }
52591
52592
52593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
52594   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52595
52596   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52597   {
52598     try {
52599       delete arg1;
52600     } catch (std::out_of_range& e) {
52601       {
52602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52603       };
52604     } catch (std::exception& e) {
52605       {
52606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52607       };
52608     } catch (...) {
52609       {
52610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52611       };
52612     }
52613   }
52614 }
52615
52616
52617 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
52618   unsigned int jresult ;
52619   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52620   bool result;
52621
52622   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52623   {
52624     try {
52625       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *)arg1);
52626     } catch (std::out_of_range& e) {
52627       {
52628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52629       };
52630     } catch (std::exception& e) {
52631       {
52632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52633       };
52634     } catch (...) {
52635       {
52636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52637       };
52638     }
52639   }
52640   jresult = result;
52641   return jresult;
52642 }
52643
52644
52645 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
52646   unsigned long jresult ;
52647   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52648   std::size_t result;
52649
52650   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52651   {
52652     try {
52653       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *)arg1);
52654     } catch (std::out_of_range& e) {
52655       {
52656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52657       };
52658     } catch (std::exception& e) {
52659       {
52660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52661       };
52662     } catch (...) {
52663       {
52664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52665       };
52666     }
52667   }
52668   jresult = (unsigned long)result;
52669   return jresult;
52670 }
52671
52672
52673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
52674   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52675   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
52676
52677   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52678   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
52679   {
52680     try {
52681       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
52682     } catch (std::out_of_range& e) {
52683       {
52684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52685       };
52686     } catch (std::exception& e) {
52687       {
52688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52689       };
52690     } catch (...) {
52691       {
52692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52693       };
52694     }
52695   }
52696 }
52697
52698
52699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
52700   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52701   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
52702
52703   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52704   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
52705   {
52706     try {
52707       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
52708     } catch (std::out_of_range& e) {
52709       {
52710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52711       };
52712     } catch (std::exception& e) {
52713       {
52714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52715       };
52716     } catch (...) {
52717       {
52718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52719       };
52720     }
52721   }
52722 }
52723
52724
52725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
52726   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52727   Dali::Actor arg2 ;
52728   bool arg3 ;
52729   Dali::DevelActor::VisibilityChange::Type arg4 ;
52730   Dali::Actor *argp2 ;
52731
52732   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52733   argp2 = (Dali::Actor *)jarg2;
52734   if (!argp2) {
52735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52736     return ;
52737   }
52738   arg2 = *argp2;
52739   arg3 = jarg3 ? true : false;
52740   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
52741   {
52742     try {
52743       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
52744     } catch (std::out_of_range& e) {
52745       {
52746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52747       };
52748     } catch (std::exception& e) {
52749       {
52750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52751       };
52752     } catch (...) {
52753       {
52754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52755       };
52756     }
52757   }
52758 }
52759
52760
52761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
52762   void * jresult ;
52763   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
52764
52765   {
52766     try {
52767       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
52768     } catch (std::out_of_range& e) {
52769       {
52770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52771       };
52772     } catch (std::exception& e) {
52773       {
52774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52775       };
52776     } catch (...) {
52777       {
52778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52779       };
52780     }
52781   }
52782   jresult = (void *)result;
52783   return jresult;
52784 }
52785
52786
52787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
52788   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52789
52790   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52791   {
52792     try {
52793       delete arg1;
52794     } catch (std::out_of_range& e) {
52795       {
52796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52797       };
52798     } catch (std::exception& e) {
52799       {
52800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52801       };
52802     } catch (...) {
52803       {
52804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52805       };
52806     }
52807   }
52808 }
52809
52810
52811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
52812   void * jresult ;
52813   Dali::Timer *result = 0 ;
52814
52815   {
52816     try {
52817       result = (Dali::Timer *)new Dali::Timer();
52818     } catch (std::out_of_range& e) {
52819       {
52820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52821       };
52822     } catch (std::exception& e) {
52823       {
52824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52825       };
52826     } catch (...) {
52827       {
52828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52829       };
52830     }
52831   }
52832   jresult = (void *)result;
52833   return jresult;
52834 }
52835
52836
52837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
52838   void * jresult ;
52839   unsigned int arg1 ;
52840   Dali::Timer result;
52841
52842   arg1 = (unsigned int)jarg1;
52843   {
52844     try {
52845       result = Dali::Timer::New(arg1);
52846     } catch (std::out_of_range& e) {
52847       {
52848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52849       };
52850     } catch (std::exception& e) {
52851       {
52852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52853       };
52854     } catch (...) {
52855       {
52856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52857       };
52858     }
52859   }
52860   jresult = new Dali::Timer((const Dali::Timer &)result);
52861   return jresult;
52862 }
52863
52864
52865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
52866   void * jresult ;
52867   Dali::Timer *arg1 = 0 ;
52868   Dali::Timer *result = 0 ;
52869
52870   arg1 = (Dali::Timer *)jarg1;
52871   if (!arg1) {
52872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
52873     return 0;
52874   }
52875   {
52876     try {
52877       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
52878     } catch (std::out_of_range& e) {
52879       {
52880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52881       };
52882     } catch (std::exception& e) {
52883       {
52884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52885       };
52886     } catch (...) {
52887       {
52888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52889       };
52890     }
52891   }
52892   jresult = (void *)result;
52893   return jresult;
52894 }
52895
52896
52897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
52898   void * jresult ;
52899   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52900   Dali::Timer *arg2 = 0 ;
52901   Dali::Timer *result = 0 ;
52902
52903   arg1 = (Dali::Timer *)jarg1;
52904   arg2 = (Dali::Timer *)jarg2;
52905   if (!arg2) {
52906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
52907     return 0;
52908   }
52909   {
52910     try {
52911       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
52912     } catch (std::out_of_range& e) {
52913       {
52914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52915       };
52916     } catch (std::exception& e) {
52917       {
52918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52919       };
52920     } catch (...) {
52921       {
52922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52923       };
52924     }
52925   }
52926   jresult = (void *)result;
52927   return jresult;
52928 }
52929
52930
52931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
52932   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52933
52934   arg1 = (Dali::Timer *)jarg1;
52935   {
52936     try {
52937       delete arg1;
52938     } catch (std::out_of_range& e) {
52939       {
52940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52941       };
52942     } catch (std::exception& e) {
52943       {
52944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52945       };
52946     } catch (...) {
52947       {
52948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52949       };
52950     }
52951   }
52952 }
52953
52954
52955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
52956   void * jresult ;
52957   Dali::BaseHandle arg1 ;
52958   Dali::BaseHandle *argp1 ;
52959   Dali::Timer result;
52960
52961   argp1 = (Dali::BaseHandle *)jarg1;
52962   if (!argp1) {
52963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
52964     return 0;
52965   }
52966   arg1 = *argp1;
52967   {
52968     try {
52969       result = Dali::Timer::DownCast(arg1);
52970     } catch (std::out_of_range& e) {
52971       {
52972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52973       };
52974     } catch (std::exception& e) {
52975       {
52976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52977       };
52978     } catch (...) {
52979       {
52980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52981       };
52982     }
52983   }
52984   jresult = new Dali::Timer((const Dali::Timer &)result);
52985   return jresult;
52986 }
52987
52988
52989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
52990   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52991
52992   arg1 = (Dali::Timer *)jarg1;
52993   {
52994     try {
52995       (arg1)->Start();
52996     } catch (std::out_of_range& e) {
52997       {
52998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52999       };
53000     } catch (std::exception& e) {
53001       {
53002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53003       };
53004     } catch (...) {
53005       {
53006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53007       };
53008     }
53009   }
53010 }
53011
53012
53013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
53014   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53015
53016   arg1 = (Dali::Timer *)jarg1;
53017   {
53018     try {
53019       (arg1)->Stop();
53020     } catch (std::out_of_range& e) {
53021       {
53022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53023       };
53024     } catch (std::exception& e) {
53025       {
53026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53027       };
53028     } catch (...) {
53029       {
53030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53031       };
53032     }
53033   }
53034 }
53035
53036
53037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
53038   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53039   unsigned int arg2 ;
53040
53041   arg1 = (Dali::Timer *)jarg1;
53042   arg2 = (unsigned int)jarg2;
53043   {
53044     try {
53045       (arg1)->SetInterval(arg2);
53046     } catch (std::out_of_range& e) {
53047       {
53048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53049       };
53050     } catch (std::exception& e) {
53051       {
53052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53053       };
53054     } catch (...) {
53055       {
53056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53057       };
53058     }
53059   }
53060 }
53061
53062
53063 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
53064   unsigned int jresult ;
53065   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53066   unsigned int result;
53067
53068   arg1 = (Dali::Timer *)jarg1;
53069   {
53070     try {
53071       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
53072     } catch (std::out_of_range& e) {
53073       {
53074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53075       };
53076     } catch (std::exception& e) {
53077       {
53078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53079       };
53080     } catch (...) {
53081       {
53082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53083       };
53084     }
53085   }
53086   jresult = result;
53087   return jresult;
53088 }
53089
53090
53091 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
53092   unsigned int jresult ;
53093   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53094   bool result;
53095
53096   arg1 = (Dali::Timer *)jarg1;
53097   {
53098     try {
53099       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
53100     } catch (std::out_of_range& e) {
53101       {
53102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53103       };
53104     } catch (std::exception& e) {
53105       {
53106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53107       };
53108     } catch (...) {
53109       {
53110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53111       };
53112     }
53113   }
53114   jresult = result;
53115   return jresult;
53116 }
53117
53118
53119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
53120   void * jresult ;
53121   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53122   Dali::Timer::TimerSignalType *result = 0 ;
53123
53124   arg1 = (Dali::Timer *)jarg1;
53125   {
53126     try {
53127       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
53128     } catch (std::out_of_range& e) {
53129       {
53130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53131       };
53132     } catch (std::exception& e) {
53133       {
53134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53135       };
53136     } catch (...) {
53137       {
53138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53139       };
53140     }
53141   }
53142   jresult = (void *)result;
53143   return jresult;
53144 }
53145
53146
53147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
53148   void * jresult ;
53149   Dali::DragAndDropDetector *result = 0 ;
53150
53151   {
53152     try {
53153       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
53154     } catch (std::out_of_range& e) {
53155       {
53156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53157       };
53158     } catch (std::exception& e) {
53159       {
53160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53161       };
53162     } catch (...) {
53163       {
53164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53165       };
53166     }
53167   }
53168   jresult = (void *)result;
53169   return jresult;
53170 }
53171
53172
53173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
53174   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53175
53176   arg1 = (Dali::DragAndDropDetector *)jarg1;
53177   {
53178     try {
53179       delete arg1;
53180     } catch (std::out_of_range& e) {
53181       {
53182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53183       };
53184     } catch (std::exception& e) {
53185       {
53186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53187       };
53188     } catch (...) {
53189       {
53190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53191       };
53192     }
53193   }
53194 }
53195
53196
53197 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
53198   char * jresult ;
53199   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53200   std::string *result = 0 ;
53201
53202   arg1 = (Dali::DragAndDropDetector *)jarg1;
53203   {
53204     try {
53205       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
53206     } catch (std::out_of_range& e) {
53207       {
53208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53209       };
53210     } catch (std::exception& e) {
53211       {
53212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53213       };
53214     } catch (...) {
53215       {
53216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53217       };
53218     }
53219   }
53220   jresult = SWIG_csharp_string_callback(result->c_str());
53221   return jresult;
53222 }
53223
53224
53225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
53226   void * jresult ;
53227   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53228   Dali::Vector2 result;
53229
53230   arg1 = (Dali::DragAndDropDetector *)jarg1;
53231   {
53232     try {
53233       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
53234     } catch (std::out_of_range& e) {
53235       {
53236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53237       };
53238     } catch (std::exception& e) {
53239       {
53240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53241       };
53242     } catch (...) {
53243       {
53244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53245       };
53246     }
53247   }
53248   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
53249   return jresult;
53250 }
53251
53252
53253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
53254   void * jresult ;
53255   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53256   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53257
53258   arg1 = (Dali::DragAndDropDetector *)jarg1;
53259   {
53260     try {
53261       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
53262     } catch (std::out_of_range& e) {
53263       {
53264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53265       };
53266     } catch (std::exception& e) {
53267       {
53268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53269       };
53270     } catch (...) {
53271       {
53272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53273       };
53274     }
53275   }
53276   jresult = (void *)result;
53277   return jresult;
53278 }
53279
53280
53281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
53282   void * jresult ;
53283   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53284   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53285
53286   arg1 = (Dali::DragAndDropDetector *)jarg1;
53287   {
53288     try {
53289       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
53290     } catch (std::out_of_range& e) {
53291       {
53292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53293       };
53294     } catch (std::exception& e) {
53295       {
53296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53297       };
53298     } catch (...) {
53299       {
53300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53301       };
53302     }
53303   }
53304   jresult = (void *)result;
53305   return jresult;
53306 }
53307
53308
53309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
53310   void * jresult ;
53311   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53312   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53313
53314   arg1 = (Dali::DragAndDropDetector *)jarg1;
53315   {
53316     try {
53317       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
53318     } catch (std::out_of_range& e) {
53319       {
53320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53321       };
53322     } catch (std::exception& e) {
53323       {
53324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53325       };
53326     } catch (...) {
53327       {
53328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53329       };
53330     }
53331   }
53332   jresult = (void *)result;
53333   return jresult;
53334 }
53335
53336
53337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_DroppedSignal(void * jarg1) {
53338   void * jresult ;
53339   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53340   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53341
53342   arg1 = (Dali::DragAndDropDetector *)jarg1;
53343   {
53344     try {
53345       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
53346     } catch (std::out_of_range& e) {
53347       {
53348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53349       };
53350     } catch (std::exception& e) {
53351       {
53352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53353       };
53354     } catch (...) {
53355       {
53356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53357       };
53358     }
53359   }
53360   jresult = (void *)result;
53361   return jresult;
53362 }
53363
53364
53365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_0() {
53366   void * jresult ;
53367   Dali::ApplicationExtensions *result = 0 ;
53368
53369   {
53370     try {
53371       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions();
53372     } catch (std::out_of_range& e) {
53373       {
53374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53375       };
53376     } catch (std::exception& e) {
53377       {
53378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53379       };
53380     } catch (...) {
53381       {
53382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53383       };
53384     }
53385   }
53386   jresult = (void *)result;
53387   return jresult;
53388 }
53389
53390
53391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_1(void * jarg1) {
53392   void * jresult ;
53393   Dali::Application *arg1 = (Dali::Application *) 0 ;
53394   Dali::ApplicationExtensions *result = 0 ;
53395
53396   arg1 = (Dali::Application *)jarg1;
53397   {
53398     try {
53399       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions(arg1);
53400     } catch (std::out_of_range& e) {
53401       {
53402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53403       };
53404     } catch (std::exception& e) {
53405       {
53406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53407       };
53408     } catch (...) {
53409       {
53410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53411       };
53412     }
53413   }
53414   jresult = (void *)result;
53415   return jresult;
53416 }
53417
53418
53419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationExtensions(void * jarg1) {
53420   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53421
53422   arg1 = (Dali::ApplicationExtensions *)jarg1;
53423   {
53424     try {
53425       delete arg1;
53426     } catch (std::out_of_range& e) {
53427       {
53428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53429       };
53430     } catch (std::exception& e) {
53431       {
53432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53433       };
53434     } catch (...) {
53435       {
53436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53437       };
53438     }
53439   }
53440 }
53441
53442
53443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Init(void * jarg1) {
53444   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53445
53446   arg1 = (Dali::ApplicationExtensions *)jarg1;
53447   {
53448     try {
53449       (arg1)->Init();
53450     } catch (std::out_of_range& e) {
53451       {
53452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53453       };
53454     } catch (std::exception& e) {
53455       {
53456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53457       };
53458     } catch (...) {
53459       {
53460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53461       };
53462     }
53463   }
53464 }
53465
53466
53467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Terminate(void * jarg1) {
53468   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53469
53470   arg1 = (Dali::ApplicationExtensions *)jarg1;
53471   {
53472     try {
53473       (arg1)->Terminate();
53474     } catch (std::out_of_range& e) {
53475       {
53476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53477       };
53478     } catch (std::exception& e) {
53479       {
53480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53481       };
53482     } catch (...) {
53483       {
53484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53485       };
53486     }
53487   }
53488 }
53489
53490
53491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Pause(void * jarg1) {
53492   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53493
53494   arg1 = (Dali::ApplicationExtensions *)jarg1;
53495   {
53496     try {
53497       (arg1)->Pause();
53498     } catch (std::out_of_range& e) {
53499       {
53500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53501       };
53502     } catch (std::exception& e) {
53503       {
53504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53505       };
53506     } catch (...) {
53507       {
53508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53509       };
53510     }
53511   }
53512 }
53513
53514
53515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Resume(void * jarg1) {
53516   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53517
53518   arg1 = (Dali::ApplicationExtensions *)jarg1;
53519   {
53520     try {
53521       (arg1)->Resume();
53522     } catch (std::out_of_range& e) {
53523       {
53524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53525       };
53526     } catch (std::exception& e) {
53527       {
53528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53529       };
53530     } catch (...) {
53531       {
53532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53533       };
53534     }
53535   }
53536 }
53537
53538
53539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_LanguageChange(void * jarg1) {
53540   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53541
53542   arg1 = (Dali::ApplicationExtensions *)jarg1;
53543   {
53544     try {
53545       (arg1)->LanguageChange();
53546     } catch (std::out_of_range& e) {
53547       {
53548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53549       };
53550     } catch (std::exception& e) {
53551       {
53552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53553       };
53554     } catch (...) {
53555       {
53556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53557       };
53558     }
53559   }
53560 }
53561
53562
53563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3) {
53564   void * jresult ;
53565   Dali::PositionSize arg1 ;
53566   std::string *arg2 = 0 ;
53567   bool arg3 ;
53568   Dali::PositionSize *argp1 ;
53569   Dali::Window result;
53570
53571   argp1 = (Dali::PositionSize *)jarg1;
53572   if (!argp1) {
53573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53574     return 0;
53575   }
53576   arg1 = *argp1;
53577   if (!jarg2) {
53578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53579     return 0;
53580   }
53581   std::string arg2_str(jarg2);
53582   arg2 = &arg2_str;
53583   arg3 = jarg3 ? true : false;
53584   {
53585     try {
53586       result = Dali::Window::New(arg1,(std::string const &)*arg2,arg3);
53587     } catch (std::out_of_range& e) {
53588       {
53589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53590       };
53591     } catch (std::exception& e) {
53592       {
53593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53594       };
53595     } catch (...) {
53596       {
53597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53598       };
53599     }
53600   }
53601   jresult = new Dali::Window((const Dali::Window &)result);
53602
53603   //argout typemap for const std::string&
53604
53605   return jresult;
53606 }
53607
53608
53609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_1(void * jarg1, char * jarg2) {
53610   void * jresult ;
53611   Dali::PositionSize arg1 ;
53612   std::string *arg2 = 0 ;
53613   Dali::PositionSize *argp1 ;
53614   Dali::Window result;
53615
53616   argp1 = (Dali::PositionSize *)jarg1;
53617   if (!argp1) {
53618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53619     return 0;
53620   }
53621   arg1 = *argp1;
53622   if (!jarg2) {
53623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53624     return 0;
53625   }
53626   std::string arg2_str(jarg2);
53627   arg2 = &arg2_str;
53628   {
53629     try {
53630       result = Dali::Window::New(arg1,(std::string const &)*arg2);
53631     } catch (std::out_of_range& e) {
53632       {
53633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53634       };
53635     } catch (std::exception& e) {
53636       {
53637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53638       };
53639     } catch (...) {
53640       {
53641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53642       };
53643     }
53644   }
53645   jresult = new Dali::Window((const Dali::Window &)result);
53646
53647   //argout typemap for const std::string&
53648
53649   return jresult;
53650 }
53651
53652
53653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_2(void * jarg1, char * jarg2, char * jarg3, unsigned int jarg4) {
53654   void * jresult ;
53655   Dali::PositionSize arg1 ;
53656   std::string *arg2 = 0 ;
53657   std::string *arg3 = 0 ;
53658   bool arg4 ;
53659   Dali::PositionSize *argp1 ;
53660   Dali::Window result;
53661
53662   argp1 = (Dali::PositionSize *)jarg1;
53663   if (!argp1) {
53664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53665     return 0;
53666   }
53667   arg1 = *argp1;
53668   if (!jarg2) {
53669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53670     return 0;
53671   }
53672   std::string arg2_str(jarg2);
53673   arg2 = &arg2_str;
53674   if (!jarg3) {
53675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53676     return 0;
53677   }
53678   std::string arg3_str(jarg3);
53679   arg3 = &arg3_str;
53680   arg4 = jarg4 ? true : false;
53681   {
53682     try {
53683       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4);
53684     } catch (std::out_of_range& e) {
53685       {
53686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53687       };
53688     } catch (std::exception& e) {
53689       {
53690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53691       };
53692     } catch (...) {
53693       {
53694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53695       };
53696     }
53697   }
53698   jresult = new Dali::Window((const Dali::Window &)result);
53699
53700   //argout typemap for const std::string&
53701
53702
53703   //argout typemap for const std::string&
53704
53705   return jresult;
53706 }
53707
53708
53709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_3(void * jarg1, char * jarg2, char * jarg3) {
53710   void * jresult ;
53711   Dali::PositionSize arg1 ;
53712   std::string *arg2 = 0 ;
53713   std::string *arg3 = 0 ;
53714   Dali::PositionSize *argp1 ;
53715   Dali::Window result;
53716
53717   argp1 = (Dali::PositionSize *)jarg1;
53718   if (!argp1) {
53719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53720     return 0;
53721   }
53722   arg1 = *argp1;
53723   if (!jarg2) {
53724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53725     return 0;
53726   }
53727   std::string arg2_str(jarg2);
53728   arg2 = &arg2_str;
53729   if (!jarg3) {
53730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53731     return 0;
53732   }
53733   std::string arg3_str(jarg3);
53734   arg3 = &arg3_str;
53735   {
53736     try {
53737       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
53738     } catch (std::out_of_range& e) {
53739       {
53740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53741       };
53742     } catch (std::exception& e) {
53743       {
53744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53745       };
53746     } catch (...) {
53747       {
53748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53749       };
53750     }
53751   }
53752   jresult = new Dali::Window((const Dali::Window &)result);
53753
53754   //argout typemap for const std::string&
53755
53756
53757   //argout typemap for const std::string&
53758
53759   return jresult;
53760 }
53761
53762
53763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_0() {
53764   void * jresult ;
53765   Dali::Window *result = 0 ;
53766
53767   {
53768     try {
53769       result = (Dali::Window *)new Dali::Window();
53770     } catch (std::out_of_range& e) {
53771       {
53772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53773       };
53774     } catch (std::exception& e) {
53775       {
53776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53777       };
53778     } catch (...) {
53779       {
53780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53781       };
53782     }
53783   }
53784   jresult = (void *)result;
53785   return jresult;
53786 }
53787
53788
53789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Window(void * jarg1) {
53790   Dali::Window *arg1 = (Dali::Window *) 0 ;
53791
53792   arg1 = (Dali::Window *)jarg1;
53793   {
53794     try {
53795       delete arg1;
53796     } catch (std::out_of_range& e) {
53797       {
53798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53799       };
53800     } catch (std::exception& e) {
53801       {
53802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53803       };
53804     } catch (...) {
53805       {
53806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53807       };
53808     }
53809   }
53810 }
53811
53812
53813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_1(void * jarg1) {
53814   void * jresult ;
53815   Dali::Window *arg1 = 0 ;
53816   Dali::Window *result = 0 ;
53817
53818   arg1 = (Dali::Window *)jarg1;
53819   if (!arg1) {
53820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
53821     return 0;
53822   }
53823   {
53824     try {
53825       result = (Dali::Window *)new Dali::Window((Dali::Window const &)*arg1);
53826     } catch (std::out_of_range& e) {
53827       {
53828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53829       };
53830     } catch (std::exception& e) {
53831       {
53832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53833       };
53834     } catch (...) {
53835       {
53836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53837       };
53838     }
53839   }
53840   jresult = (void *)result;
53841   return jresult;
53842 }
53843
53844
53845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Assign(void * jarg1, void * jarg2) {
53846   void * jresult ;
53847   Dali::Window *arg1 = (Dali::Window *) 0 ;
53848   Dali::Window *arg2 = 0 ;
53849   Dali::Window *result = 0 ;
53850
53851   arg1 = (Dali::Window *)jarg1;
53852   arg2 = (Dali::Window *)jarg2;
53853   if (!arg2) {
53854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
53855     return 0;
53856   }
53857   {
53858     try {
53859       result = (Dali::Window *) &(arg1)->operator =((Dali::Window const &)*arg2);
53860     } catch (std::out_of_range& e) {
53861       {
53862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53863       };
53864     } catch (std::exception& e) {
53865       {
53866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53867       };
53868     } catch (...) {
53869       {
53870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53871       };
53872     }
53873   }
53874   jresult = (void *)result;
53875   return jresult;
53876 }
53877
53878
53879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_ShowIndicator(void * jarg1, int jarg2) {
53880   Dali::Window *arg1 = (Dali::Window *) 0 ;
53881   Dali::Window::IndicatorVisibleMode arg2 ;
53882
53883   arg1 = (Dali::Window *)jarg1;
53884   arg2 = (Dali::Window::IndicatorVisibleMode)jarg2;
53885   {
53886     try {
53887       (arg1)->ShowIndicator(arg2);
53888     } catch (std::out_of_range& e) {
53889       {
53890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53891       };
53892     } catch (std::exception& e) {
53893       {
53894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53895       };
53896     } catch (...) {
53897       {
53898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53899       };
53900     }
53901   }
53902 }
53903
53904
53905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetIndicatorBgOpacity(void * jarg1, int jarg2) {
53906   Dali::Window *arg1 = (Dali::Window *) 0 ;
53907   Dali::Window::IndicatorBgOpacity arg2 ;
53908
53909   arg1 = (Dali::Window *)jarg1;
53910   arg2 = (Dali::Window::IndicatorBgOpacity)jarg2;
53911   {
53912     try {
53913       (arg1)->SetIndicatorBgOpacity(arg2);
53914     } catch (std::out_of_range& e) {
53915       {
53916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53917       };
53918     } catch (std::exception& e) {
53919       {
53920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53921       };
53922     } catch (...) {
53923       {
53924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53925       };
53926     }
53927   }
53928 }
53929
53930
53931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RotateIndicator(void * jarg1, int jarg2) {
53932   Dali::Window *arg1 = (Dali::Window *) 0 ;
53933   Dali::Window::WindowOrientation arg2 ;
53934
53935   arg1 = (Dali::Window *)jarg1;
53936   arg2 = (Dali::Window::WindowOrientation)jarg2;
53937   {
53938     try {
53939       (arg1)->RotateIndicator(arg2);
53940     } catch (std::out_of_range& e) {
53941       {
53942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53943       };
53944     } catch (std::exception& e) {
53945       {
53946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53947       };
53948     } catch (...) {
53949       {
53950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53951       };
53952     }
53953   }
53954 }
53955
53956
53957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetClass(void * jarg1, char * jarg2, char * jarg3) {
53958   Dali::Window *arg1 = (Dali::Window *) 0 ;
53959   std::string arg2 ;
53960   std::string arg3 ;
53961
53962   arg1 = (Dali::Window *)jarg1;
53963   if (!jarg2) {
53964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53965     return ;
53966   }
53967   (&arg2)->assign(jarg2);
53968   if (!jarg3) {
53969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53970     return ;
53971   }
53972   (&arg3)->assign(jarg3);
53973   {
53974     try {
53975       (arg1)->SetClass(arg2,arg3);
53976     } catch (std::out_of_range& e) {
53977       {
53978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53979       };
53980     } catch (std::exception& e) {
53981       {
53982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53983       };
53984     } catch (...) {
53985       {
53986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53987       };
53988     }
53989   }
53990 }
53991
53992
53993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Raise(void * jarg1) {
53994   Dali::Window *arg1 = (Dali::Window *) 0 ;
53995
53996   arg1 = (Dali::Window *)jarg1;
53997   {
53998     try {
53999       (arg1)->Raise();
54000     } catch (std::out_of_range& e) {
54001       {
54002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54003       };
54004     } catch (std::exception& e) {
54005       {
54006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54007       };
54008     } catch (...) {
54009       {
54010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54011       };
54012     }
54013   }
54014 }
54015
54016
54017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Lower(void * jarg1) {
54018   Dali::Window *arg1 = (Dali::Window *) 0 ;
54019
54020   arg1 = (Dali::Window *)jarg1;
54021   {
54022     try {
54023       (arg1)->Lower();
54024     } catch (std::out_of_range& e) {
54025       {
54026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54027       };
54028     } catch (std::exception& e) {
54029       {
54030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54031       };
54032     } catch (...) {
54033       {
54034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54035       };
54036     }
54037   }
54038 }
54039
54040
54041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Activate(void * jarg1) {
54042   Dali::Window *arg1 = (Dali::Window *) 0 ;
54043
54044   arg1 = (Dali::Window *)jarg1;
54045   {
54046     try {
54047       (arg1)->Activate();
54048     } catch (std::out_of_range& e) {
54049       {
54050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54051       };
54052     } catch (std::exception& e) {
54053       {
54054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54055       };
54056     } catch (...) {
54057       {
54058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54059       };
54060     }
54061   }
54062 }
54063
54064
54065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_AddAvailableOrientation(void * jarg1, int jarg2) {
54066   Dali::Window *arg1 = (Dali::Window *) 0 ;
54067   Dali::Window::WindowOrientation arg2 ;
54068
54069   arg1 = (Dali::Window *)jarg1;
54070   arg2 = (Dali::Window::WindowOrientation)jarg2;
54071   {
54072     try {
54073       (arg1)->AddAvailableOrientation(arg2);
54074     } catch (std::out_of_range& e) {
54075       {
54076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54077       };
54078     } catch (std::exception& e) {
54079       {
54080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54081       };
54082     } catch (...) {
54083       {
54084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54085       };
54086     }
54087   }
54088 }
54089
54090
54091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RemoveAvailableOrientation(void * jarg1, int jarg2) {
54092   Dali::Window *arg1 = (Dali::Window *) 0 ;
54093   Dali::Window::WindowOrientation arg2 ;
54094
54095   arg1 = (Dali::Window *)jarg1;
54096   arg2 = (Dali::Window::WindowOrientation)jarg2;
54097   {
54098     try {
54099       (arg1)->RemoveAvailableOrientation(arg2);
54100     } catch (std::out_of_range& e) {
54101       {
54102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54103       };
54104     } catch (std::exception& e) {
54105       {
54106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54107       };
54108     } catch (...) {
54109       {
54110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54111       };
54112     }
54113   }
54114 }
54115
54116
54117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetPreferredOrientation(void * jarg1, int jarg2) {
54118   Dali::Window *arg1 = (Dali::Window *) 0 ;
54119   Dali::Window::WindowOrientation arg2 ;
54120
54121   arg1 = (Dali::Window *)jarg1;
54122   arg2 = (Dali::Window::WindowOrientation)jarg2;
54123   {
54124     try {
54125       (arg1)->SetPreferredOrientation(arg2);
54126     } catch (std::out_of_range& e) {
54127       {
54128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54129       };
54130     } catch (std::exception& e) {
54131       {
54132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54133       };
54134     } catch (...) {
54135       {
54136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54137       };
54138     }
54139   }
54140 }
54141
54142
54143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Window_GetPreferredOrientation(void * jarg1) {
54144   int jresult ;
54145   Dali::Window *arg1 = (Dali::Window *) 0 ;
54146   Dali::Window::WindowOrientation result;
54147
54148   arg1 = (Dali::Window *)jarg1;
54149   {
54150     try {
54151       result = (Dali::Window::WindowOrientation)(arg1)->GetPreferredOrientation();
54152     } catch (std::out_of_range& e) {
54153       {
54154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54155       };
54156     } catch (std::exception& e) {
54157       {
54158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54159       };
54160     } catch (...) {
54161       {
54162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54163       };
54164     }
54165   }
54166   jresult = (int)result;
54167   return jresult;
54168 }
54169
54170
54171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetDragAndDropDetector(void * jarg1) {
54172   void * jresult ;
54173   Dali::Window *arg1 = (Dali::Window *) 0 ;
54174   Dali::DragAndDropDetector result;
54175
54176   arg1 = (Dali::Window *)jarg1;
54177   {
54178     try {
54179       result = ((Dali::Window const *)arg1)->GetDragAndDropDetector();
54180     } catch (std::out_of_range& e) {
54181       {
54182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54183       };
54184     } catch (std::exception& e) {
54185       {
54186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54187       };
54188     } catch (...) {
54189       {
54190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54191       };
54192     }
54193   }
54194   jresult = new Dali::DragAndDropDetector((const Dali::DragAndDropDetector &)result);
54195   return jresult;
54196 }
54197
54198
54199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetNativeHandle(void * jarg1) {
54200   void * jresult ;
54201   Dali::Window *arg1 = (Dali::Window *) 0 ;
54202   Dali::Any result;
54203
54204   arg1 = (Dali::Window *)jarg1;
54205   {
54206     try {
54207       result = ((Dali::Window const *)arg1)->GetNativeHandle();
54208     } catch (std::out_of_range& e) {
54209       {
54210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54211       };
54212     } catch (std::exception& e) {
54213       {
54214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54215       };
54216     } catch (...) {
54217       {
54218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54219       };
54220     }
54221   }
54222   jresult = new Dali::Any((const Dali::Any &)result);
54223   return jresult;
54224 }
54225
54226
54227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FocusChangedSignal(void * jarg1) {
54228   void * jresult ;
54229   Dali::Window arg1 ;
54230   Dali::Window *argp1 ;
54231   Dali::DevelWindow::FocusSignalType *result = 0 ;
54232
54233   argp1 = (Dali::Window *)jarg1;
54234   if (!argp1) {
54235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54236     return 0;
54237   }
54238   arg1 = *argp1;
54239   {
54240     try {
54241       result = (Dali::DevelWindow::FocusSignalType *) &Dali::DevelWindow::FocusChangedSignal(arg1);
54242     } catch (std::out_of_range& e) {
54243       {
54244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54245       };
54246     } catch (std::exception& e) {
54247       {
54248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54249       };
54250     } catch (...) {
54251       {
54252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54253       };
54254     }
54255   }
54256   jresult = (void *)result;
54257   return jresult;
54258 }
54259
54260
54261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetAcceptFocus(void * jarg1, unsigned int jarg2) {
54262   Dali::Window arg1 ;
54263   bool arg2 ;
54264   Dali::Window *argp1 ;
54265
54266   argp1 = (Dali::Window *)jarg1;
54267   if (!argp1) {
54268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54269     return ;
54270   }
54271   arg1 = *argp1;
54272   arg2 = jarg2 ? true : false;
54273   {
54274     try {
54275       Dali::DevelWindow::SetAcceptFocus(arg1,arg2);
54276     } catch (std::out_of_range& e) {
54277       {
54278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54279       };
54280     } catch (std::exception& e) {
54281       {
54282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54283       };
54284     } catch (...) {
54285       {
54286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54287       };
54288     }
54289   }
54290 }
54291
54292
54293 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsFocusAcceptable(void * jarg1) {
54294   unsigned int jresult ;
54295   Dali::Window arg1 ;
54296   Dali::Window *argp1 ;
54297   bool result;
54298
54299   argp1 = (Dali::Window *)jarg1;
54300   if (!argp1) {
54301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54302     return 0;
54303   }
54304   arg1 = *argp1;
54305   {
54306     try {
54307       result = (bool)Dali::DevelWindow::IsFocusAcceptable(arg1);
54308     } catch (std::out_of_range& e) {
54309       {
54310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54311       };
54312     } catch (std::exception& e) {
54313       {
54314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54315       };
54316     } catch (...) {
54317       {
54318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54319       };
54320     }
54321   }
54322   jresult = result;
54323   return jresult;
54324 }
54325
54326
54327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Show(void * jarg1) {
54328   Dali::Window arg1 ;
54329   Dali::Window *argp1 ;
54330
54331   argp1 = (Dali::Window *)jarg1;
54332   if (!argp1) {
54333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54334     return ;
54335   }
54336   arg1 = *argp1;
54337   {
54338     try {
54339       Dali::DevelWindow::Show(arg1);
54340     } catch (std::out_of_range& e) {
54341       {
54342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54343       };
54344     } catch (std::exception& e) {
54345       {
54346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54347       };
54348     } catch (...) {
54349       {
54350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54351       };
54352     }
54353   }
54354 }
54355
54356
54357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hide(void * jarg1) {
54358   Dali::Window arg1 ;
54359   Dali::Window *argp1 ;
54360
54361   argp1 = (Dali::Window *)jarg1;
54362   if (!argp1) {
54363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54364     return ;
54365   }
54366   arg1 = *argp1;
54367   {
54368     try {
54369       Dali::DevelWindow::Hide(arg1);
54370     } catch (std::out_of_range& e) {
54371       {
54372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54373       };
54374     } catch (std::exception& e) {
54375       {
54376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54377       };
54378     } catch (...) {
54379       {
54380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54381       };
54382     }
54383   }
54384 }
54385
54386
54387 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVisible(void * jarg1) {
54388   unsigned int jresult ;
54389   Dali::Window arg1 ;
54390   Dali::Window *argp1 ;
54391   bool result;
54392
54393   argp1 = (Dali::Window *)jarg1;
54394   if (!argp1) {
54395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54396     return 0;
54397   }
54398   arg1 = *argp1;
54399   {
54400     try {
54401       result = (bool)Dali::DevelWindow::IsVisible(arg1);
54402     } catch (std::out_of_range& e) {
54403       {
54404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54405       };
54406     } catch (std::exception& e) {
54407       {
54408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54409       };
54410     } catch (...) {
54411       {
54412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54413       };
54414     }
54415   }
54416   jresult = result;
54417   return jresult;
54418 }
54419
54420
54421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_0() {
54422   void * jresult ;
54423   Dali::Application result;
54424
54425   {
54426     try {
54427       result = Dali::Application::New();
54428     } catch (std::out_of_range& e) {
54429       {
54430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54431       };
54432     } catch (std::exception& e) {
54433       {
54434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54435       };
54436     } catch (...) {
54437       {
54438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54439       };
54440     }
54441   }
54442   jresult = new Dali::Application((const Dali::Application &)result);
54443   return jresult;
54444 }
54445
54446
54447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_1(int jarg1) {
54448   void * jresult ;
54449   int *arg1 = (int *) 0 ;
54450   char ***arg2 ;
54451   Dali::Application result;
54452
54453   {
54454     // Todo generate argv data from the C# args
54455     char **array;         // two dimensional array
54456     int numStrings = 1;     // number of strings
54457     int stringLength = 30;      // max string length.
54458     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
54459     argV = array;
54460
54461     // allocate the string data
54462     for( int i=0; i < numStrings; i++)
54463     {
54464       array[i]=(char *)malloc( stringLength * sizeof(char *) );
54465     }
54466     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
54467
54468     strcpy( array[0], "dali-csharp-app");
54469
54470     arg1 = &argC;
54471     arg2 = &argV;
54472   }
54473   {
54474     try {
54475       result = Dali::Application::New(arg1,arg2);
54476     } catch (std::out_of_range& e) {
54477       {
54478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54479       };
54480     } catch (std::exception& e) {
54481       {
54482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54483       };
54484     } catch (...) {
54485       {
54486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54487       };
54488     }
54489   }
54490   jresult = new Dali::Application((const Dali::Application &)result);
54491   return jresult;
54492 }
54493
54494
54495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_2(int jarg1, char * jarg3) {
54496   void * jresult ;
54497   int *arg1 = (int *) 0 ;
54498   char ***arg2 ;
54499   std::string *arg3 = 0 ;
54500   Dali::Application result;
54501
54502   {
54503     // Todo generate argv data from the C# args
54504     char **array;         // two dimensional array
54505     int numStrings = 1;     // number of strings
54506     int stringLength = 30;      // max string length.
54507     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
54508     argV = array;
54509
54510     // allocate the string data
54511     for( int i=0; i < numStrings; i++)
54512     {
54513       array[i]=(char *)malloc( stringLength * sizeof(char *) );
54514     }
54515     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
54516
54517     strcpy( array[0], "dali-csharp-app");
54518
54519     arg1 = &argC;
54520     arg2 = &argV;
54521   }
54522   if (!jarg3) {
54523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54524     return 0;
54525   }
54526   std::string arg3_str(jarg3);
54527   arg3 = &arg3_str;
54528   {
54529     try {
54530       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3);
54531     } catch (std::out_of_range& e) {
54532       {
54533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54534       };
54535     } catch (std::exception& e) {
54536       {
54537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54538       };
54539     } catch (...) {
54540       {
54541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54542       };
54543     }
54544   }
54545   jresult = new Dali::Application((const Dali::Application &)result);
54546
54547   //argout typemap for const std::string&
54548
54549   return jresult;
54550 }
54551
54552
54553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_3(int jarg1, char * jarg3, int jarg4) {
54554   void * jresult ;
54555   int *arg1 = (int *) 0 ;
54556   char ***arg2 ;
54557   std::string *arg3 = 0 ;
54558   Dali::Application::WINDOW_MODE arg4 ;
54559   Dali::Application result;
54560
54561   {
54562     // Todo generate argv data from the C# args
54563     char **array;         // two dimensional array
54564     int numStrings = 1;     // number of strings
54565     int stringLength = 30;      // max string length.
54566     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
54567     argV = array;
54568
54569     // allocate the string data
54570     for( int i=0; i < numStrings; i++)
54571     {
54572       array[i]=(char *)malloc( stringLength * sizeof(char *) );
54573     }
54574     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
54575
54576     strcpy( array[0], "dali-csharp-app");
54577
54578     arg1 = &argC;
54579     arg2 = &argV;
54580   }
54581   if (!jarg3) {
54582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54583     return 0;
54584   }
54585   std::string arg3_str(jarg3);
54586   arg3 = &arg3_str;
54587   arg4 = (Dali::Application::WINDOW_MODE)jarg4;
54588   {
54589     try {
54590       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3,arg4);
54591     } catch (std::out_of_range& e) {
54592       {
54593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54594       };
54595     } catch (std::exception& e) {
54596       {
54597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54598       };
54599     } catch (...) {
54600       {
54601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54602       };
54603     }
54604   }
54605   jresult = new Dali::Application((const Dali::Application &)result);
54606
54607   //argout typemap for const std::string&
54608
54609   return jresult;
54610 }
54611
54612
54613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_0() {
54614   void * jresult ;
54615   Dali::Application *result = 0 ;
54616
54617   {
54618     try {
54619       result = (Dali::Application *)new Dali::Application();
54620     } catch (std::out_of_range& e) {
54621       {
54622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54623       };
54624     } catch (std::exception& e) {
54625       {
54626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54627       };
54628     } catch (...) {
54629       {
54630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54631       };
54632     }
54633   }
54634   jresult = (void *)result;
54635   return jresult;
54636 }
54637
54638
54639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_1(void * jarg1) {
54640   void * jresult ;
54641   Dali::Application *arg1 = 0 ;
54642   Dali::Application *result = 0 ;
54643
54644   arg1 = (Dali::Application *)jarg1;
54645   if (!arg1) {
54646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
54647     return 0;
54648   }
54649   {
54650     try {
54651       result = (Dali::Application *)new Dali::Application((Dali::Application const &)*arg1);
54652     } catch (std::out_of_range& e) {
54653       {
54654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54655       };
54656     } catch (std::exception& e) {
54657       {
54658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54659       };
54660     } catch (...) {
54661       {
54662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54663       };
54664     }
54665   }
54666   jresult = (void *)result;
54667   return jresult;
54668 }
54669
54670
54671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_Assign(void * jarg1, void * jarg2) {
54672   void * jresult ;
54673   Dali::Application *arg1 = (Dali::Application *) 0 ;
54674   Dali::Application *arg2 = 0 ;
54675   Dali::Application *result = 0 ;
54676
54677   arg1 = (Dali::Application *)jarg1;
54678   arg2 = (Dali::Application *)jarg2;
54679   if (!arg2) {
54680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
54681     return 0;
54682   }
54683   {
54684     try {
54685       result = (Dali::Application *) &(arg1)->operator =((Dali::Application const &)*arg2);
54686     } catch (std::out_of_range& e) {
54687       {
54688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54689       };
54690     } catch (std::exception& e) {
54691       {
54692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54693       };
54694     } catch (...) {
54695       {
54696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54697       };
54698     }
54699   }
54700   jresult = (void *)result;
54701   return jresult;
54702 }
54703
54704
54705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Application(void * jarg1) {
54706   Dali::Application *arg1 = (Dali::Application *) 0 ;
54707
54708   arg1 = (Dali::Application *)jarg1;
54709   {
54710     try {
54711       delete arg1;
54712     } catch (std::out_of_range& e) {
54713       {
54714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54715       };
54716     } catch (std::exception& e) {
54717       {
54718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54719       };
54720     } catch (...) {
54721       {
54722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54723       };
54724     }
54725   }
54726 }
54727
54728
54729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_0(void * jarg1) {
54730   Dali::Application *arg1 = (Dali::Application *) 0 ;
54731
54732   arg1 = (Dali::Application *)jarg1;
54733   {
54734     try {
54735       (arg1)->MainLoop();
54736     } catch (std::out_of_range& e) {
54737       {
54738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54739       };
54740     } catch (std::exception& e) {
54741       {
54742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54743       };
54744     } catch (...) {
54745       {
54746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54747       };
54748     }
54749   }
54750 }
54751
54752
54753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_1(void * jarg1, void * jarg2) {
54754   Dali::Application *arg1 = (Dali::Application *) 0 ;
54755   Configuration::ContextLoss arg2 ;
54756   Configuration::ContextLoss *argp2 ;
54757
54758   arg1 = (Dali::Application *)jarg1;
54759   argp2 = (Configuration::ContextLoss *)jarg2;
54760   if (!argp2) {
54761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Configuration::ContextLoss", 0);
54762     return ;
54763   }
54764   arg2 = *argp2;
54765   {
54766     try {
54767       (arg1)->MainLoop(arg2);
54768     } catch (std::out_of_range& e) {
54769       {
54770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54771       };
54772     } catch (std::exception& e) {
54773       {
54774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54775       };
54776     } catch (...) {
54777       {
54778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54779       };
54780     }
54781   }
54782 }
54783
54784
54785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Lower(void * jarg1) {
54786   Dali::Application *arg1 = (Dali::Application *) 0 ;
54787
54788   arg1 = (Dali::Application *)jarg1;
54789   {
54790     try {
54791       (arg1)->Lower();
54792     } catch (std::out_of_range& e) {
54793       {
54794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54795       };
54796     } catch (std::exception& e) {
54797       {
54798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54799       };
54800     } catch (...) {
54801       {
54802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54803       };
54804     }
54805   }
54806 }
54807
54808
54809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Quit(void * jarg1) {
54810   Dali::Application *arg1 = (Dali::Application *) 0 ;
54811
54812   arg1 = (Dali::Application *)jarg1;
54813   {
54814     try {
54815       (arg1)->Quit();
54816     } catch (std::out_of_range& e) {
54817       {
54818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54819       };
54820     } catch (std::exception& e) {
54821       {
54822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54823       };
54824     } catch (...) {
54825       {
54826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54827       };
54828     }
54829   }
54830 }
54831
54832
54833 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_AddIdle(void * jarg1, void * jarg2) {
54834   unsigned int jresult ;
54835   Dali::Application *arg1 = (Dali::Application *) 0 ;
54836   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
54837   bool result;
54838
54839   arg1 = (Dali::Application *)jarg1;
54840   arg2 = (Dali::CallbackBase *)jarg2;
54841   {
54842     try {
54843       result = (bool)(arg1)->AddIdle(arg2);
54844     } catch (std::out_of_range& e) {
54845       {
54846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54847       };
54848     } catch (std::exception& e) {
54849       {
54850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54851       };
54852     } catch (...) {
54853       {
54854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54855       };
54856     }
54857   }
54858   jresult = result;
54859   return jresult;
54860 }
54861
54862
54863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_GetWindow(void * jarg1) {
54864   void * jresult ;
54865   Dali::Application *arg1 = (Dali::Application *) 0 ;
54866   Dali::Window result;
54867
54868   arg1 = (Dali::Application *)jarg1;
54869   {
54870     try {
54871       result = (arg1)->GetWindow();
54872     } catch (std::out_of_range& e) {
54873       {
54874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54875       };
54876     } catch (std::exception& e) {
54877       {
54878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54879       };
54880     } catch (...) {
54881       {
54882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54883       };
54884     }
54885   }
54886   jresult = new Dali::Window((const Dali::Window &)result);
54887   return jresult;
54888 }
54889
54890
54891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_ReplaceWindow(void * jarg1, void * jarg2, char * jarg3) {
54892   Dali::Application *arg1 = (Dali::Application *) 0 ;
54893   Dali::PositionSize arg2 ;
54894   std::string *arg3 = 0 ;
54895   Dali::PositionSize *argp2 ;
54896
54897   arg1 = (Dali::Application *)jarg1;
54898   argp2 = (Dali::PositionSize *)jarg2;
54899   if (!argp2) {
54900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
54901     return ;
54902   }
54903   arg2 = *argp2;
54904   if (!jarg3) {
54905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54906     return ;
54907   }
54908   std::string arg3_str(jarg3);
54909   arg3 = &arg3_str;
54910   {
54911     try {
54912       (arg1)->ReplaceWindow(arg2,(std::string const &)*arg3);
54913     } catch (std::out_of_range& e) {
54914       {
54915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54916       };
54917     } catch (std::exception& e) {
54918       {
54919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54920       };
54921     } catch (...) {
54922       {
54923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54924       };
54925     }
54926   }
54927
54928   //argout typemap for const std::string&
54929
54930 }
54931
54932
54933 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Application_GetResourcePath() {
54934   char * jresult ;
54935   std::string result;
54936
54937   {
54938     try {
54939       result = Dali::Application::GetResourcePath();
54940     } catch (std::out_of_range& e) {
54941       {
54942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54943       };
54944     } catch (std::exception& e) {
54945       {
54946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54947       };
54948     } catch (...) {
54949       {
54950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54951       };
54952     }
54953   }
54954   jresult = SWIG_csharp_string_callback((&result)->c_str());
54955   return jresult;
54956 }
54957
54958
54959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetViewMode(void * jarg1, int jarg2) {
54960   Dali::Application *arg1 = (Dali::Application *) 0 ;
54961   Dali::ViewMode arg2 ;
54962
54963   arg1 = (Dali::Application *)jarg1;
54964   arg2 = (Dali::ViewMode)jarg2;
54965   {
54966     try {
54967       (arg1)->SetViewMode(arg2);
54968     } catch (std::out_of_range& e) {
54969       {
54970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54971       };
54972     } catch (std::exception& e) {
54973       {
54974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54975       };
54976     } catch (...) {
54977       {
54978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54979       };
54980     }
54981   }
54982 }
54983
54984
54985 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Application_GetViewMode(void * jarg1) {
54986   int jresult ;
54987   Dali::Application *arg1 = (Dali::Application *) 0 ;
54988   Dali::ViewMode result;
54989
54990   arg1 = (Dali::Application *)jarg1;
54991   {
54992     try {
54993       result = (Dali::ViewMode)((Dali::Application const *)arg1)->GetViewMode();
54994     } catch (std::out_of_range& e) {
54995       {
54996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54997       };
54998     } catch (std::exception& e) {
54999       {
55000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55001       };
55002     } catch (...) {
55003       {
55004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55005       };
55006     }
55007   }
55008   jresult = (int)result;
55009   return jresult;
55010 }
55011
55012
55013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetStereoBase(void * jarg1, float jarg2) {
55014   Dali::Application *arg1 = (Dali::Application *) 0 ;
55015   float arg2 ;
55016
55017   arg1 = (Dali::Application *)jarg1;
55018   arg2 = (float)jarg2;
55019   {
55020     try {
55021       (arg1)->SetStereoBase(arg2);
55022     } catch (std::out_of_range& e) {
55023       {
55024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55025       };
55026     } catch (std::exception& e) {
55027       {
55028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55029       };
55030     } catch (...) {
55031       {
55032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55033       };
55034     }
55035   }
55036 }
55037
55038
55039 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Application_GetStereoBase(void * jarg1) {
55040   float jresult ;
55041   Dali::Application *arg1 = (Dali::Application *) 0 ;
55042   float result;
55043
55044   arg1 = (Dali::Application *)jarg1;
55045   {
55046     try {
55047       result = (float)((Dali::Application const *)arg1)->GetStereoBase();
55048     } catch (std::out_of_range& e) {
55049       {
55050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55051       };
55052     } catch (std::exception& e) {
55053       {
55054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55055       };
55056     } catch (...) {
55057       {
55058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55059       };
55060     }
55061   }
55062   jresult = result;
55063   return jresult;
55064 }
55065
55066
55067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_InitSignal(void * jarg1) {
55068   void * jresult ;
55069   Dali::Application *arg1 = (Dali::Application *) 0 ;
55070   Dali::Application::AppSignalType *result = 0 ;
55071
55072   arg1 = (Dali::Application *)jarg1;
55073   {
55074     try {
55075       result = (Dali::Application::AppSignalType *) &(arg1)->InitSignal();
55076     } catch (std::out_of_range& e) {
55077       {
55078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55079       };
55080     } catch (std::exception& e) {
55081       {
55082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55083       };
55084     } catch (...) {
55085       {
55086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55087       };
55088     }
55089   }
55090   jresult = (void *)result;
55091   return jresult;
55092 }
55093
55094
55095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_TerminateSignal(void * jarg1) {
55096   void * jresult ;
55097   Dali::Application *arg1 = (Dali::Application *) 0 ;
55098   Dali::Application::AppSignalType *result = 0 ;
55099
55100   arg1 = (Dali::Application *)jarg1;
55101   {
55102     try {
55103       result = (Dali::Application::AppSignalType *) &(arg1)->TerminateSignal();
55104     } catch (std::out_of_range& e) {
55105       {
55106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55107       };
55108     } catch (std::exception& e) {
55109       {
55110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55111       };
55112     } catch (...) {
55113       {
55114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55115       };
55116     }
55117   }
55118   jresult = (void *)result;
55119   return jresult;
55120 }
55121
55122
55123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_PauseSignal(void * jarg1) {
55124   void * jresult ;
55125   Dali::Application *arg1 = (Dali::Application *) 0 ;
55126   Dali::Application::AppSignalType *result = 0 ;
55127
55128   arg1 = (Dali::Application *)jarg1;
55129   {
55130     try {
55131       result = (Dali::Application::AppSignalType *) &(arg1)->PauseSignal();
55132     } catch (std::out_of_range& e) {
55133       {
55134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55135       };
55136     } catch (std::exception& e) {
55137       {
55138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55139       };
55140     } catch (...) {
55141       {
55142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55143       };
55144     }
55145   }
55146   jresult = (void *)result;
55147   return jresult;
55148 }
55149
55150
55151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResumeSignal(void * jarg1) {
55152   void * jresult ;
55153   Dali::Application *arg1 = (Dali::Application *) 0 ;
55154   Dali::Application::AppSignalType *result = 0 ;
55155
55156   arg1 = (Dali::Application *)jarg1;
55157   {
55158     try {
55159       result = (Dali::Application::AppSignalType *) &(arg1)->ResumeSignal();
55160     } catch (std::out_of_range& e) {
55161       {
55162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55163       };
55164     } catch (std::exception& e) {
55165       {
55166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55167       };
55168     } catch (...) {
55169       {
55170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55171       };
55172     }
55173   }
55174   jresult = (void *)result;
55175   return jresult;
55176 }
55177
55178
55179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResetSignal(void * jarg1) {
55180   void * jresult ;
55181   Dali::Application *arg1 = (Dali::Application *) 0 ;
55182   Dali::Application::AppSignalType *result = 0 ;
55183
55184   arg1 = (Dali::Application *)jarg1;
55185   {
55186     try {
55187       result = (Dali::Application::AppSignalType *) &(arg1)->ResetSignal();
55188     } catch (std::out_of_range& e) {
55189       {
55190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55191       };
55192     } catch (std::exception& e) {
55193       {
55194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55195       };
55196     } catch (...) {
55197       {
55198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55199       };
55200     }
55201   }
55202   jresult = (void *)result;
55203   return jresult;
55204 }
55205
55206
55207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResizeSignal(void * jarg1) {
55208   void * jresult ;
55209   Dali::Application *arg1 = (Dali::Application *) 0 ;
55210   Dali::Application::AppSignalType *result = 0 ;
55211
55212   arg1 = (Dali::Application *)jarg1;
55213   {
55214     try {
55215       result = (Dali::Application::AppSignalType *) &(arg1)->ResizeSignal();
55216     } catch (std::out_of_range& e) {
55217       {
55218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55219       };
55220     } catch (std::exception& e) {
55221       {
55222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55223       };
55224     } catch (...) {
55225       {
55226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55227       };
55228     }
55229   }
55230   jresult = (void *)result;
55231   return jresult;
55232 }
55233
55234
55235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_AppControlSignal(void * jarg1) {
55236   void * jresult ;
55237   Dali::Application *arg1 = (Dali::Application *) 0 ;
55238   Dali::Application::AppControlSignalType *result = 0 ;
55239
55240   arg1 = (Dali::Application *)jarg1;
55241   {
55242     try {
55243       result = (Dali::Application::AppControlSignalType *) &(arg1)->AppControlSignal();
55244     } catch (std::out_of_range& e) {
55245       {
55246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55247       };
55248     } catch (std::exception& e) {
55249       {
55250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55251       };
55252     } catch (...) {
55253       {
55254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55255       };
55256     }
55257   }
55258   jresult = (void *)result;
55259   return jresult;
55260 }
55261
55262
55263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_LanguageChangedSignal(void * jarg1) {
55264   void * jresult ;
55265   Dali::Application *arg1 = (Dali::Application *) 0 ;
55266   Dali::Application::AppSignalType *result = 0 ;
55267
55268   arg1 = (Dali::Application *)jarg1;
55269   {
55270     try {
55271       result = (Dali::Application::AppSignalType *) &(arg1)->LanguageChangedSignal();
55272     } catch (std::out_of_range& e) {
55273       {
55274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55275       };
55276     } catch (std::exception& e) {
55277       {
55278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55279       };
55280     } catch (...) {
55281       {
55282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55283       };
55284     }
55285   }
55286   jresult = (void *)result;
55287   return jresult;
55288 }
55289
55290
55291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_RegionChangedSignal(void * jarg1) {
55292   void * jresult ;
55293   Dali::Application *arg1 = (Dali::Application *) 0 ;
55294   Dali::Application::AppSignalType *result = 0 ;
55295
55296   arg1 = (Dali::Application *)jarg1;
55297   {
55298     try {
55299       result = (Dali::Application::AppSignalType *) &(arg1)->RegionChangedSignal();
55300     } catch (std::out_of_range& e) {
55301       {
55302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55303       };
55304     } catch (std::exception& e) {
55305       {
55306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55307       };
55308     } catch (...) {
55309       {
55310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55311       };
55312     }
55313   }
55314   jresult = (void *)result;
55315   return jresult;
55316 }
55317
55318
55319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_BatteryLowSignal(void * jarg1) {
55320   void * jresult ;
55321   Dali::Application *arg1 = (Dali::Application *) 0 ;
55322   Dali::Application::AppSignalType *result = 0 ;
55323
55324   arg1 = (Dali::Application *)jarg1;
55325   {
55326     try {
55327       result = (Dali::Application::AppSignalType *) &(arg1)->BatteryLowSignal();
55328     } catch (std::out_of_range& e) {
55329       {
55330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55331       };
55332     } catch (std::exception& e) {
55333       {
55334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55335       };
55336     } catch (...) {
55337       {
55338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55339       };
55340     }
55341   }
55342   jresult = (void *)result;
55343   return jresult;
55344 }
55345
55346
55347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_MemoryLowSignal(void * jarg1) {
55348   void * jresult ;
55349   Dali::Application *arg1 = (Dali::Application *) 0 ;
55350   Dali::Application::AppSignalType *result = 0 ;
55351
55352   arg1 = (Dali::Application *)jarg1;
55353   {
55354     try {
55355       result = (Dali::Application::AppSignalType *) &(arg1)->MemoryLowSignal();
55356     } catch (std::out_of_range& e) {
55357       {
55358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55359       };
55360     } catch (std::exception& e) {
55361       {
55362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55363       };
55364     } catch (...) {
55365       {
55366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55367       };
55368     }
55369   }
55370   jresult = (void *)result;
55371   return jresult;
55372 }
55373
55374
55375 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationSignal_Empty(void * jarg1) {
55376   unsigned int jresult ;
55377   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55378   bool result;
55379
55380   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55381   {
55382     try {
55383       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Application &) > const *)arg1);
55384     } catch (std::out_of_range& e) {
55385       {
55386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55387       };
55388     } catch (std::exception& e) {
55389       {
55390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55391       };
55392     } catch (...) {
55393       {
55394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55395       };
55396     }
55397   }
55398   jresult = result;
55399   return jresult;
55400 }
55401
55402
55403 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationSignal_GetConnectionCount(void * jarg1) {
55404   unsigned long jresult ;
55405   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55406   std::size_t result;
55407
55408   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55409   {
55410     try {
55411       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &) > const *)arg1);
55412     } catch (std::out_of_range& e) {
55413       {
55414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55415       };
55416     } catch (std::exception& e) {
55417       {
55418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55419       };
55420     } catch (...) {
55421       {
55422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55423       };
55424     }
55425   }
55426   jresult = (unsigned long)result;
55427   return jresult;
55428 }
55429
55430
55431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Connect(void * jarg1, void * jarg2) {
55432   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55433   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
55434
55435   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55436   arg2 = (void (*)(Dali::Application &))jarg2;
55437   {
55438     try {
55439       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(arg1,arg2);
55440     } catch (std::out_of_range& e) {
55441       {
55442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55443       };
55444     } catch (std::exception& e) {
55445       {
55446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55447       };
55448     } catch (...) {
55449       {
55450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55451       };
55452     }
55453   }
55454 }
55455
55456
55457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Disconnect(void * jarg1, void * jarg2) {
55458   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55459   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
55460
55461   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55462   arg2 = (void (*)(Dali::Application &))jarg2;
55463   {
55464     try {
55465       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(arg1,arg2);
55466     } catch (std::out_of_range& e) {
55467       {
55468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55469       };
55470     } catch (std::exception& e) {
55471       {
55472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55473       };
55474     } catch (...) {
55475       {
55476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55477       };
55478     }
55479   }
55480 }
55481
55482
55483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Emit(void * jarg1, void * jarg2) {
55484   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55485   Dali::Application *arg2 = 0 ;
55486
55487   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55488   arg2 = (Dali::Application *)jarg2;
55489   if (!arg2) {
55490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
55491     return ;
55492   }
55493   {
55494     try {
55495       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(arg1,*arg2);
55496     } catch (std::out_of_range& e) {
55497       {
55498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55499       };
55500     } catch (std::exception& e) {
55501       {
55502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55503       };
55504     } catch (...) {
55505       {
55506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55507       };
55508     }
55509   }
55510 }
55511
55512
55513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationSignal() {
55514   void * jresult ;
55515   Dali::Signal< void (Dali::Application &) > *result = 0 ;
55516
55517   {
55518     try {
55519       result = (Dali::Signal< void (Dali::Application &) > *)new Dali::Signal< void (Dali::Application &) >();
55520     } catch (std::out_of_range& e) {
55521       {
55522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55523       };
55524     } catch (std::exception& e) {
55525       {
55526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55527       };
55528     } catch (...) {
55529       {
55530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55531       };
55532     }
55533   }
55534   jresult = (void *)result;
55535   return jresult;
55536 }
55537
55538
55539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationSignal(void * jarg1) {
55540   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55541
55542   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55543   {
55544     try {
55545       delete arg1;
55546     } catch (std::out_of_range& e) {
55547       {
55548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55549       };
55550     } catch (std::exception& e) {
55551       {
55552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55553       };
55554     } catch (...) {
55555       {
55556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55557       };
55558     }
55559   }
55560 }
55561
55562
55563 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Empty(void * jarg1) {
55564   unsigned int jresult ;
55565   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55566   bool result;
55567
55568   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55569   {
55570     try {
55571       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
55572     } catch (std::out_of_range& e) {
55573       {
55574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55575       };
55576     } catch (std::exception& e) {
55577       {
55578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55579       };
55580     } catch (...) {
55581       {
55582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55583       };
55584     }
55585   }
55586   jresult = result;
55587   return jresult;
55588 }
55589
55590
55591 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_GetConnectionCount(void * jarg1) {
55592   unsigned long jresult ;
55593   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55594   std::size_t result;
55595
55596   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55597   {
55598     try {
55599       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
55600     } catch (std::out_of_range& e) {
55601       {
55602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55603       };
55604     } catch (std::exception& e) {
55605       {
55606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55607       };
55608     } catch (...) {
55609       {
55610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55611       };
55612     }
55613   }
55614   jresult = (unsigned long)result;
55615   return jresult;
55616 }
55617
55618
55619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Connect(void * jarg1, void * jarg2) {
55620   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55621   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
55622
55623   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55624   arg2 = (void (*)(Dali::Application &,void *))jarg2;
55625   {
55626     try {
55627       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(arg1,arg2);
55628     } catch (std::out_of_range& e) {
55629       {
55630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55631       };
55632     } catch (std::exception& e) {
55633       {
55634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55635       };
55636     } catch (...) {
55637       {
55638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55639       };
55640     }
55641   }
55642 }
55643
55644
55645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Disconnect(void * jarg1, void * jarg2) {
55646   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55647   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
55648
55649   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55650   arg2 = (void (*)(Dali::Application &,void *))jarg2;
55651   {
55652     try {
55653       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(arg1,arg2);
55654     } catch (std::out_of_range& e) {
55655       {
55656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55657       };
55658     } catch (std::exception& e) {
55659       {
55660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55661       };
55662     } catch (...) {
55663       {
55664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55665       };
55666     }
55667   }
55668 }
55669
55670
55671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55672   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55673   Dali::Application *arg2 = 0 ;
55674   void *arg3 = (void *) 0 ;
55675
55676   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55677   arg2 = (Dali::Application *)jarg2;
55678   if (!arg2) {
55679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
55680     return ;
55681   }
55682   arg3 = jarg3;
55683   {
55684     try {
55685       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(arg1,*arg2,arg3);
55686     } catch (std::out_of_range& e) {
55687       {
55688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55689       };
55690     } catch (std::exception& e) {
55691       {
55692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55693       };
55694     } catch (...) {
55695       {
55696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55697       };
55698     }
55699   }
55700 }
55701
55702
55703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationControlSignal() {
55704   void * jresult ;
55705   Dali::Signal< void (Dali::Application &,void *) > *result = 0 ;
55706
55707   {
55708     try {
55709       result = (Dali::Signal< void (Dali::Application &,void *) > *)new Dali::Signal< void (Dali::Application &,void *) >();
55710     } catch (std::out_of_range& e) {
55711       {
55712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55713       };
55714     } catch (std::exception& e) {
55715       {
55716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55717       };
55718     } catch (...) {
55719       {
55720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55721       };
55722     }
55723   }
55724   jresult = (void *)result;
55725   return jresult;
55726 }
55727
55728
55729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationControlSignal(void * jarg1) {
55730   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55731
55732   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55733   {
55734     try {
55735       delete arg1;
55736     } catch (std::out_of_range& e) {
55737       {
55738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55739       };
55740     } catch (std::exception& e) {
55741       {
55742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55743       };
55744     } catch (...) {
55745       {
55746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55747       };
55748     }
55749   }
55750 }
55751
55752
55753 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
55754   unsigned int jresult ;
55755   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55756   bool result;
55757
55758   arg1 = (Dali::Signal< bool () > *)jarg1;
55759   {
55760     try {
55761       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
55762     } catch (std::out_of_range& e) {
55763       {
55764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55765       };
55766     } catch (std::exception& e) {
55767       {
55768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55769       };
55770     } catch (...) {
55771       {
55772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55773       };
55774     }
55775   }
55776   jresult = result;
55777   return jresult;
55778 }
55779
55780
55781 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
55782   unsigned long jresult ;
55783   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55784   std::size_t result;
55785
55786   arg1 = (Dali::Signal< bool () > *)jarg1;
55787   {
55788     try {
55789       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
55790     } catch (std::out_of_range& e) {
55791       {
55792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55793       };
55794     } catch (std::exception& e) {
55795       {
55796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55797       };
55798     } catch (...) {
55799       {
55800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55801       };
55802     }
55803   }
55804   jresult = (unsigned long)result;
55805   return jresult;
55806 }
55807
55808
55809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
55810   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55811   bool (*arg2)() = (bool (*)()) 0 ;
55812
55813   arg1 = (Dali::Signal< bool () > *)jarg1;
55814   arg2 = (bool (*)())jarg2;
55815   {
55816     try {
55817       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
55818     } catch (std::out_of_range& e) {
55819       {
55820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55821       };
55822     } catch (std::exception& e) {
55823       {
55824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55825       };
55826     } catch (...) {
55827       {
55828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55829       };
55830     }
55831   }
55832 }
55833
55834
55835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
55836   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55837   bool (*arg2)() = (bool (*)()) 0 ;
55838
55839   arg1 = (Dali::Signal< bool () > *)jarg1;
55840   arg2 = (bool (*)())jarg2;
55841   {
55842     try {
55843       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
55844     } catch (std::out_of_range& e) {
55845       {
55846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55847       };
55848     } catch (std::exception& e) {
55849       {
55850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55851       };
55852     } catch (...) {
55853       {
55854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55855       };
55856     }
55857   }
55858 }
55859
55860
55861 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
55862   unsigned int jresult ;
55863   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55864   bool result;
55865
55866   arg1 = (Dali::Signal< bool () > *)jarg1;
55867   {
55868     try {
55869       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
55870     } catch (std::out_of_range& e) {
55871       {
55872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55873       };
55874     } catch (std::exception& e) {
55875       {
55876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55877       };
55878     } catch (...) {
55879       {
55880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55881       };
55882     }
55883   }
55884   jresult = result;
55885   return jresult;
55886 }
55887
55888
55889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
55890   void * jresult ;
55891   Dali::Signal< bool () > *result = 0 ;
55892
55893   {
55894     try {
55895       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
55896     } catch (std::out_of_range& e) {
55897       {
55898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55899       };
55900     } catch (std::exception& e) {
55901       {
55902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55903       };
55904     } catch (...) {
55905       {
55906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55907       };
55908     }
55909   }
55910   jresult = (void *)result;
55911   return jresult;
55912 }
55913
55914
55915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
55916   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55917
55918   arg1 = (Dali::Signal< bool () > *)jarg1;
55919   {
55920     try {
55921       delete arg1;
55922     } catch (std::out_of_range& e) {
55923       {
55924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55925       };
55926     } catch (std::exception& e) {
55927       {
55928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55929       };
55930     } catch (...) {
55931       {
55932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55933       };
55934     }
55935   }
55936 }
55937
55938
55939 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Empty(void * jarg1) {
55940   unsigned int jresult ;
55941   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55942   bool result;
55943
55944   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55945   {
55946     try {
55947       result = (bool)Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty((Dali::Signal< void (bool) > const *)arg1);
55948     } catch (std::out_of_range& e) {
55949       {
55950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55951       };
55952     } catch (std::exception& e) {
55953       {
55954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55955       };
55956     } catch (...) {
55957       {
55958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55959       };
55960     }
55961   }
55962   jresult = result;
55963   return jresult;
55964 }
55965
55966
55967 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_GetConnectionCount(void * jarg1) {
55968   unsigned long jresult ;
55969   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55970   std::size_t result;
55971
55972   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55973   {
55974     try {
55975       result = Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (bool) > const *)arg1);
55976     } catch (std::out_of_range& e) {
55977       {
55978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55979       };
55980     } catch (std::exception& e) {
55981       {
55982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55983       };
55984     } catch (...) {
55985       {
55986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55987       };
55988     }
55989   }
55990   jresult = (unsigned long)result;
55991   return jresult;
55992 }
55993
55994
55995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Connect(void * jarg1, void * jarg2) {
55996   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55997   void (*arg2)(bool) = (void (*)(bool)) 0 ;
55998
55999   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56000   arg2 = (void (*)(bool))jarg2;
56001   {
56002     try {
56003       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(arg1,arg2);
56004     } catch (std::out_of_range& e) {
56005       {
56006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56007       };
56008     } catch (std::exception& e) {
56009       {
56010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56011       };
56012     } catch (...) {
56013       {
56014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56015       };
56016     }
56017   }
56018 }
56019
56020
56021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Disconnect(void * jarg1, void * jarg2) {
56022   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56023   void (*arg2)(bool) = (void (*)(bool)) 0 ;
56024
56025   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56026   arg2 = (void (*)(bool))jarg2;
56027   {
56028     try {
56029       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(arg1,arg2);
56030     } catch (std::out_of_range& e) {
56031       {
56032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56033       };
56034     } catch (std::exception& e) {
56035       {
56036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56037       };
56038     } catch (...) {
56039       {
56040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56041       };
56042     }
56043   }
56044 }
56045
56046
56047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Emit(void * jarg1, unsigned int jarg2) {
56048   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56049   bool arg2 ;
56050
56051   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56052   arg2 = jarg2 ? true : false;
56053   {
56054     try {
56055       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(arg1,arg2);
56056     } catch (std::out_of_range& e) {
56057       {
56058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56059       };
56060     } catch (std::exception& e) {
56061       {
56062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56063       };
56064     } catch (...) {
56065       {
56066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56067       };
56068     }
56069   }
56070 }
56071
56072
56073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WindowFocusSignalType() {
56074   void * jresult ;
56075   Dali::Signal< void (bool) > *result = 0 ;
56076
56077   {
56078     try {
56079       result = (Dali::Signal< void (bool) > *)new Dali::Signal< void (bool) >();
56080     } catch (std::out_of_range& e) {
56081       {
56082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56083       };
56084     } catch (std::exception& e) {
56085       {
56086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56087       };
56088     } catch (...) {
56089       {
56090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56091       };
56092     }
56093   }
56094   jresult = (void *)result;
56095   return jresult;
56096 }
56097
56098
56099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WindowFocusSignalType(void * jarg1) {
56100   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56101
56102   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56103   {
56104     try {
56105       delete arg1;
56106     } catch (std::out_of_range& e) {
56107       {
56108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56109       };
56110     } catch (std::exception& e) {
56111       {
56112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56113       };
56114     } catch (...) {
56115       {
56116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56117       };
56118     }
56119   }
56120 }
56121
56122
56123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
56124   int jresult ;
56125   int result;
56126
56127   {
56128     try {
56129       result = (int)Dali::Toolkit::Visual::Property::TYPE;
56130     } catch (std::out_of_range& e) {
56131       {
56132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56133       };
56134     } catch (std::exception& e) {
56135       {
56136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56137       };
56138     } catch (...) {
56139       {
56140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56141       };
56142     }
56143   }
56144   jresult = (int)result;
56145   return jresult;
56146 }
56147
56148
56149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
56150   int jresult ;
56151   int result;
56152
56153   {
56154     try {
56155       result = (int)Dali::Toolkit::Visual::Property::SHADER;
56156     } catch (std::out_of_range& e) {
56157       {
56158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56159       };
56160     } catch (std::exception& e) {
56161       {
56162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56163       };
56164     } catch (...) {
56165       {
56166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56167       };
56168     }
56169   }
56170   jresult = (int)result;
56171   return jresult;
56172 }
56173
56174
56175 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
56176   int jresult ;
56177   int result;
56178
56179   {
56180     try {
56181       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
56182     } catch (std::out_of_range& e) {
56183       {
56184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56185       };
56186     } catch (std::exception& e) {
56187       {
56188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56189       };
56190     } catch (...) {
56191       {
56192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56193       };
56194     }
56195   }
56196   jresult = (int)result;
56197   return jresult;
56198 }
56199
56200
56201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
56202   int jresult ;
56203   int result;
56204
56205   {
56206     try {
56207       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
56208     } catch (std::out_of_range& e) {
56209       {
56210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56211       };
56212     } catch (std::exception& e) {
56213       {
56214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56215       };
56216     } catch (...) {
56217       {
56218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56219       };
56220     }
56221   }
56222   jresult = (int)result;
56223   return jresult;
56224 }
56225
56226
56227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
56228   int jresult ;
56229   int result;
56230
56231   {
56232     try {
56233       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
56234     } catch (std::out_of_range& e) {
56235       {
56236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56237       };
56238     } catch (std::exception& e) {
56239       {
56240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56241       };
56242     } catch (...) {
56243       {
56244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56245       };
56246     }
56247   }
56248   jresult = (int)result;
56249   return jresult;
56250 }
56251
56252
56253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
56254   int jresult ;
56255   int result;
56256
56257   {
56258     try {
56259       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
56260     } catch (std::out_of_range& e) {
56261       {
56262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56263       };
56264     } catch (std::exception& e) {
56265       {
56266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56267       };
56268     } catch (...) {
56269       {
56270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56271       };
56272     }
56273   }
56274   jresult = (int)result;
56275   return jresult;
56276 }
56277
56278
56279 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
56280   int jresult ;
56281   int result;
56282
56283   {
56284     try {
56285       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
56286     } catch (std::out_of_range& e) {
56287       {
56288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56289       };
56290     } catch (std::exception& e) {
56291       {
56292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56293       };
56294     } catch (...) {
56295       {
56296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56297       };
56298     }
56299   }
56300   jresult = (int)result;
56301   return jresult;
56302 }
56303
56304
56305 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
56306   int jresult ;
56307   int result;
56308
56309   {
56310     try {
56311       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
56312     } catch (std::out_of_range& e) {
56313       {
56314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56315       };
56316     } catch (std::exception& e) {
56317       {
56318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56319       };
56320     } catch (...) {
56321       {
56322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56323       };
56324     }
56325   }
56326   jresult = (int)result;
56327   return jresult;
56328 }
56329
56330
56331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
56332   int jresult ;
56333   int result;
56334
56335   {
56336     try {
56337       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
56338     } catch (std::out_of_range& e) {
56339       {
56340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56341       };
56342     } catch (std::exception& e) {
56343       {
56344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56345       };
56346     } catch (...) {
56347       {
56348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56349       };
56350     }
56351   }
56352   jresult = (int)result;
56353   return jresult;
56354 }
56355
56356
56357 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
56358   int jresult ;
56359   int result;
56360
56361   {
56362     try {
56363       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
56364     } catch (std::out_of_range& e) {
56365       {
56366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56367       };
56368     } catch (std::exception& e) {
56369       {
56370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56371       };
56372     } catch (...) {
56373       {
56374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56375       };
56376     }
56377   }
56378   jresult = (int)result;
56379   return jresult;
56380 }
56381
56382
56383 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
56384   int jresult ;
56385   int result;
56386
56387   {
56388     try {
56389       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
56390     } catch (std::out_of_range& e) {
56391       {
56392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56393       };
56394     } catch (std::exception& e) {
56395       {
56396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56397       };
56398     } catch (...) {
56399       {
56400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56401       };
56402     }
56403   }
56404   jresult = (int)result;
56405   return jresult;
56406 }
56407
56408
56409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
56410   int jresult ;
56411   int result;
56412
56413   {
56414     try {
56415       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
56416     } catch (std::out_of_range& e) {
56417       {
56418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56419       };
56420     } catch (std::exception& e) {
56421       {
56422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56423       };
56424     } catch (...) {
56425       {
56426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56427       };
56428     }
56429   }
56430   jresult = (int)result;
56431   return jresult;
56432 }
56433
56434
56435 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
56436   int jresult ;
56437   int result;
56438
56439   {
56440     try {
56441       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
56442     } catch (std::out_of_range& e) {
56443       {
56444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56445       };
56446     } catch (std::exception& e) {
56447       {
56448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56449       };
56450     } catch (...) {
56451       {
56452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56453       };
56454     }
56455   }
56456   jresult = (int)result;
56457   return jresult;
56458 }
56459
56460
56461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
56462   int jresult ;
56463   int result;
56464
56465   {
56466     try {
56467       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
56468     } catch (std::out_of_range& e) {
56469       {
56470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56471       };
56472     } catch (std::exception& e) {
56473       {
56474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56475       };
56476     } catch (...) {
56477       {
56478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56479       };
56480     }
56481   }
56482   jresult = (int)result;
56483   return jresult;
56484 }
56485
56486
56487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
56488   int jresult ;
56489   int result;
56490
56491   {
56492     try {
56493       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
56494     } catch (std::out_of_range& e) {
56495       {
56496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56497       };
56498     } catch (std::exception& e) {
56499       {
56500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56501       };
56502     } catch (...) {
56503       {
56504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56505       };
56506     }
56507   }
56508   jresult = (int)result;
56509   return jresult;
56510 }
56511
56512
56513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
56514   int jresult ;
56515   int result;
56516
56517   {
56518     try {
56519       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
56520     } catch (std::out_of_range& e) {
56521       {
56522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56523       };
56524     } catch (std::exception& e) {
56525       {
56526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56527       };
56528     } catch (...) {
56529       {
56530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56531       };
56532     }
56533   }
56534   jresult = (int)result;
56535   return jresult;
56536 }
56537
56538
56539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
56540   int jresult ;
56541   int result;
56542
56543   {
56544     try {
56545       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
56546     } catch (std::out_of_range& e) {
56547       {
56548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56549       };
56550     } catch (std::exception& e) {
56551       {
56552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56553       };
56554     } catch (...) {
56555       {
56556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56557       };
56558     }
56559   }
56560   jresult = (int)result;
56561   return jresult;
56562 }
56563
56564
56565 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
56566   int jresult ;
56567   int result;
56568
56569   {
56570     try {
56571       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
56572     } catch (std::out_of_range& e) {
56573       {
56574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56575       };
56576     } catch (std::exception& e) {
56577       {
56578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56579       };
56580     } catch (...) {
56581       {
56582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56583       };
56584     }
56585   }
56586   jresult = (int)result;
56587   return jresult;
56588 }
56589
56590
56591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
56592   int jresult ;
56593   int result;
56594
56595   {
56596     try {
56597       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
56598     } catch (std::out_of_range& e) {
56599       {
56600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56601       };
56602     } catch (std::exception& e) {
56603       {
56604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56605       };
56606     } catch (...) {
56607       {
56608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56609       };
56610     }
56611   }
56612   jresult = (int)result;
56613   return jresult;
56614 }
56615
56616
56617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
56618   int jresult ;
56619   int result;
56620
56621   {
56622     try {
56623       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
56624     } catch (std::out_of_range& e) {
56625       {
56626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56627       };
56628     } catch (std::exception& e) {
56629       {
56630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56631       };
56632     } catch (...) {
56633       {
56634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56635       };
56636     }
56637   }
56638   jresult = (int)result;
56639   return jresult;
56640 }
56641
56642
56643 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
56644   int jresult ;
56645   int result;
56646
56647   {
56648     try {
56649       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
56650     } catch (std::out_of_range& e) {
56651       {
56652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56653       };
56654     } catch (std::exception& e) {
56655       {
56656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56657       };
56658     } catch (...) {
56659       {
56660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56661       };
56662     }
56663   }
56664   jresult = (int)result;
56665   return jresult;
56666 }
56667
56668
56669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
56670   int jresult ;
56671   int result;
56672
56673   {
56674     try {
56675       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
56676     } catch (std::out_of_range& e) {
56677       {
56678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56679       };
56680     } catch (std::exception& e) {
56681       {
56682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56683       };
56684     } catch (...) {
56685       {
56686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56687       };
56688     }
56689   }
56690   jresult = (int)result;
56691   return jresult;
56692 }
56693
56694
56695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
56696   int jresult ;
56697   int result;
56698
56699   {
56700     try {
56701       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
56702     } catch (std::out_of_range& e) {
56703       {
56704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56705       };
56706     } catch (std::exception& e) {
56707       {
56708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56709       };
56710     } catch (...) {
56711       {
56712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56713       };
56714     }
56715   }
56716   jresult = (int)result;
56717   return jresult;
56718 }
56719
56720
56721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
56722   int jresult ;
56723   int result;
56724
56725   {
56726     try {
56727       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
56728     } catch (std::out_of_range& e) {
56729       {
56730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56731       };
56732     } catch (std::exception& e) {
56733       {
56734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56735       };
56736     } catch (...) {
56737       {
56738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56739       };
56740     }
56741   }
56742   jresult = (int)result;
56743   return jresult;
56744 }
56745
56746
56747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
56748   int jresult ;
56749   int result;
56750
56751   {
56752     try {
56753       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
56754     } catch (std::out_of_range& e) {
56755       {
56756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56757       };
56758     } catch (std::exception& e) {
56759       {
56760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56761       };
56762     } catch (...) {
56763       {
56764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56765       };
56766     }
56767   }
56768   jresult = (int)result;
56769   return jresult;
56770 }
56771
56772
56773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
56774   int jresult ;
56775   int result;
56776
56777   {
56778     try {
56779       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
56780     } catch (std::out_of_range& e) {
56781       {
56782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56783       };
56784     } catch (std::exception& e) {
56785       {
56786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56787       };
56788     } catch (...) {
56789       {
56790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56791       };
56792     }
56793   }
56794   jresult = (int)result;
56795   return jresult;
56796 }
56797
56798
56799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
56800   int jresult ;
56801   int result;
56802
56803   {
56804     try {
56805       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
56806     } catch (std::out_of_range& e) {
56807       {
56808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56809       };
56810     } catch (std::exception& e) {
56811       {
56812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56813       };
56814     } catch (...) {
56815       {
56816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56817       };
56818     }
56819   }
56820   jresult = (int)result;
56821   return jresult;
56822 }
56823
56824
56825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
56826   int jresult ;
56827   int result;
56828
56829   {
56830     try {
56831       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
56832     } catch (std::out_of_range& e) {
56833       {
56834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56835       };
56836     } catch (std::exception& e) {
56837       {
56838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56839       };
56840     } catch (...) {
56841       {
56842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56843       };
56844     }
56845   }
56846   jresult = (int)result;
56847   return jresult;
56848 }
56849
56850
56851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
56852   int jresult ;
56853   int result;
56854
56855   {
56856     try {
56857       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
56858     } catch (std::out_of_range& e) {
56859       {
56860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56861       };
56862     } catch (std::exception& e) {
56863       {
56864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56865       };
56866     } catch (...) {
56867       {
56868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56869       };
56870     }
56871   }
56872   jresult = (int)result;
56873   return jresult;
56874 }
56875
56876
56877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
56878   int jresult ;
56879   int result;
56880
56881   {
56882     try {
56883       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
56884     } catch (std::out_of_range& e) {
56885       {
56886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56887       };
56888     } catch (std::exception& e) {
56889       {
56890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56891       };
56892     } catch (...) {
56893       {
56894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56895       };
56896     }
56897   }
56898   jresult = (int)result;
56899   return jresult;
56900 }
56901
56902
56903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
56904   int jresult ;
56905   int result;
56906
56907   {
56908     try {
56909       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
56910     } catch (std::out_of_range& e) {
56911       {
56912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56913       };
56914     } catch (std::exception& e) {
56915       {
56916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56917       };
56918     } catch (...) {
56919       {
56920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56921       };
56922     }
56923   }
56924   jresult = (int)result;
56925   return jresult;
56926 }
56927
56928
56929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
56930   int jresult ;
56931   int result;
56932
56933   {
56934     try {
56935       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
56936     } catch (std::out_of_range& e) {
56937       {
56938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56939       };
56940     } catch (std::exception& e) {
56941       {
56942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56943       };
56944     } catch (...) {
56945       {
56946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56947       };
56948     }
56949   }
56950   jresult = (int)result;
56951   return jresult;
56952 }
56953
56954
56955 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
56956   int jresult ;
56957   int result;
56958
56959   {
56960     try {
56961       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
56962     } catch (std::out_of_range& e) {
56963       {
56964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56965       };
56966     } catch (std::exception& e) {
56967       {
56968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56969       };
56970     } catch (...) {
56971       {
56972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56973       };
56974     }
56975   }
56976   jresult = (int)result;
56977   return jresult;
56978 }
56979
56980
56981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
56982   int jresult ;
56983   int result;
56984
56985   {
56986     try {
56987       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
56988     } catch (std::out_of_range& e) {
56989       {
56990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56991       };
56992     } catch (std::exception& e) {
56993       {
56994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56995       };
56996     } catch (...) {
56997       {
56998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56999       };
57000     }
57001   }
57002   jresult = (int)result;
57003   return jresult;
57004 }
57005
57006
57007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
57008   int jresult ;
57009   int result;
57010
57011   {
57012     try {
57013       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
57014     } catch (std::out_of_range& e) {
57015       {
57016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57017       };
57018     } catch (std::exception& e) {
57019       {
57020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57021       };
57022     } catch (...) {
57023       {
57024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57025       };
57026     }
57027   }
57028   jresult = (int)result;
57029   return jresult;
57030 }
57031
57032
57033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
57034   int jresult ;
57035   int result;
57036
57037   {
57038     try {
57039       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
57040     } catch (std::out_of_range& e) {
57041       {
57042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57043       };
57044     } catch (std::exception& e) {
57045       {
57046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57047       };
57048     } catch (...) {
57049       {
57050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57051       };
57052     }
57053   }
57054   jresult = (int)result;
57055   return jresult;
57056 }
57057
57058
57059 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
57060   int jresult ;
57061   int result;
57062
57063   {
57064     try {
57065       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
57066     } catch (std::out_of_range& e) {
57067       {
57068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57069       };
57070     } catch (std::exception& e) {
57071       {
57072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57073       };
57074     } catch (...) {
57075       {
57076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57077       };
57078     }
57079   }
57080   jresult = (int)result;
57081   return jresult;
57082 }
57083
57084
57085 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
57086   int jresult ;
57087   int result;
57088
57089   {
57090     try {
57091       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
57092     } catch (std::out_of_range& e) {
57093       {
57094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57095       };
57096     } catch (std::exception& e) {
57097       {
57098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57099       };
57100     } catch (...) {
57101       {
57102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57103       };
57104     }
57105   }
57106   jresult = (int)result;
57107   return jresult;
57108 }
57109
57110
57111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
57112   int jresult ;
57113   int result;
57114
57115   {
57116     try {
57117       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
57118     } catch (std::out_of_range& e) {
57119       {
57120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57121       };
57122     } catch (std::exception& e) {
57123       {
57124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57125       };
57126     } catch (...) {
57127       {
57128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57129       };
57130     }
57131   }
57132   jresult = (int)result;
57133   return jresult;
57134 }
57135
57136
57137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
57138   int jresult ;
57139   int result;
57140
57141   {
57142     try {
57143       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
57144     } catch (std::out_of_range& e) {
57145       {
57146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57147       };
57148     } catch (std::exception& e) {
57149       {
57150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57151       };
57152     } catch (...) {
57153       {
57154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57155       };
57156     }
57157   }
57158   jresult = (int)result;
57159   return jresult;
57160 }
57161
57162
57163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
57164   int jresult ;
57165   int result;
57166
57167   {
57168     try {
57169       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
57170     } catch (std::out_of_range& e) {
57171       {
57172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57173       };
57174     } catch (std::exception& e) {
57175       {
57176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57177       };
57178     } catch (...) {
57179       {
57180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57181       };
57182     }
57183   }
57184   jresult = (int)result;
57185   return jresult;
57186 }
57187
57188
57189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
57190   int jresult ;
57191   int result;
57192
57193   {
57194     try {
57195       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
57196     } catch (std::out_of_range& e) {
57197       {
57198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57199       };
57200     } catch (std::exception& e) {
57201       {
57202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57203       };
57204     } catch (...) {
57205       {
57206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57207       };
57208     }
57209   }
57210   jresult = (int)result;
57211   return jresult;
57212 }
57213
57214
57215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
57216   int jresult ;
57217   int result;
57218
57219   {
57220     try {
57221       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
57222     } catch (std::out_of_range& e) {
57223       {
57224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57225       };
57226     } catch (std::exception& e) {
57227       {
57228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57229       };
57230     } catch (...) {
57231       {
57232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57233       };
57234     }
57235   }
57236   jresult = (int)result;
57237   return jresult;
57238 }
57239
57240
57241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
57242   int jresult ;
57243   int result;
57244
57245   {
57246     try {
57247       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
57248     } catch (std::out_of_range& e) {
57249       {
57250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57251       };
57252     } catch (std::exception& e) {
57253       {
57254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57255       };
57256     } catch (...) {
57257       {
57258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57259       };
57260     }
57261   }
57262   jresult = (int)result;
57263   return jresult;
57264 }
57265
57266
57267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
57268   int jresult ;
57269   int result;
57270
57271   {
57272     try {
57273       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
57274     } catch (std::out_of_range& e) {
57275       {
57276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57277       };
57278     } catch (std::exception& e) {
57279       {
57280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57281       };
57282     } catch (...) {
57283       {
57284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57285       };
57286     }
57287   }
57288   jresult = (int)result;
57289   return jresult;
57290 }
57291
57292
57293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
57294   int jresult ;
57295   int result;
57296
57297   {
57298     try {
57299       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
57300     } catch (std::out_of_range& e) {
57301       {
57302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57303       };
57304     } catch (std::exception& e) {
57305       {
57306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57307       };
57308     } catch (...) {
57309       {
57310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57311       };
57312     }
57313   }
57314   jresult = (int)result;
57315   return jresult;
57316 }
57317
57318
57319 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
57320   int jresult ;
57321   int result;
57322
57323   {
57324     try {
57325       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
57326     } catch (std::out_of_range& e) {
57327       {
57328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57329       };
57330     } catch (std::exception& e) {
57331       {
57332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57333       };
57334     } catch (...) {
57335       {
57336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57337       };
57338     }
57339   }
57340   jresult = (int)result;
57341   return jresult;
57342 }
57343
57344
57345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
57346   int jresult ;
57347   int result;
57348
57349   {
57350     try {
57351       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
57352     } catch (std::out_of_range& e) {
57353       {
57354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57355       };
57356     } catch (std::exception& e) {
57357       {
57358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57359       };
57360     } catch (...) {
57361       {
57362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57363       };
57364     }
57365   }
57366   jresult = (int)result;
57367   return jresult;
57368 }
57369
57370
57371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
57372   int jresult ;
57373   int result;
57374
57375   {
57376     try {
57377       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
57378     } catch (std::out_of_range& e) {
57379       {
57380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57381       };
57382     } catch (std::exception& e) {
57383       {
57384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57385       };
57386     } catch (...) {
57387       {
57388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57389       };
57390     }
57391   }
57392   jresult = (int)result;
57393   return jresult;
57394 }
57395
57396
57397 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
57398   int jresult ;
57399   int result;
57400
57401   {
57402     try {
57403       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
57404     } catch (std::out_of_range& e) {
57405       {
57406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57407       };
57408     } catch (std::exception& e) {
57409       {
57410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57411       };
57412     } catch (...) {
57413       {
57414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57415       };
57416     }
57417   }
57418   jresult = (int)result;
57419   return jresult;
57420 }
57421
57422
57423 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
57424   int jresult ;
57425   int result;
57426
57427   {
57428     try {
57429       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
57430     } catch (std::out_of_range& e) {
57431       {
57432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57433       };
57434     } catch (std::exception& e) {
57435       {
57436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57437       };
57438     } catch (...) {
57439       {
57440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57441       };
57442     }
57443   }
57444   jresult = (int)result;
57445   return jresult;
57446 }
57447
57448
57449 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
57450   int jresult ;
57451   int result;
57452
57453   {
57454     try {
57455       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
57456     } catch (std::out_of_range& e) {
57457       {
57458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57459       };
57460     } catch (std::exception& e) {
57461       {
57462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57463       };
57464     } catch (...) {
57465       {
57466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57467       };
57468     }
57469   }
57470   jresult = (int)result;
57471   return jresult;
57472 }
57473
57474
57475 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
57476   int jresult ;
57477   int result;
57478
57479   {
57480     try {
57481       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
57482     } catch (std::out_of_range& e) {
57483       {
57484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57485       };
57486     } catch (std::exception& e) {
57487       {
57488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57489       };
57490     } catch (...) {
57491       {
57492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57493       };
57494     }
57495   }
57496   jresult = (int)result;
57497   return jresult;
57498 }
57499
57500
57501 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
57502   int jresult ;
57503   int result;
57504
57505   {
57506     try {
57507       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
57508     } catch (std::out_of_range& e) {
57509       {
57510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57511       };
57512     } catch (std::exception& e) {
57513       {
57514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57515       };
57516     } catch (...) {
57517       {
57518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57519       };
57520     }
57521   }
57522   jresult = (int)result;
57523   return jresult;
57524 }
57525
57526
57527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
57528   int jresult ;
57529   int result;
57530
57531   {
57532     try {
57533       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
57534     } catch (std::out_of_range& e) {
57535       {
57536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57537       };
57538     } catch (std::exception& e) {
57539       {
57540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57541       };
57542     } catch (...) {
57543       {
57544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57545       };
57546     }
57547   }
57548   jresult = (int)result;
57549   return jresult;
57550 }
57551
57552
57553 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
57554   int jresult ;
57555   int result;
57556
57557   {
57558     try {
57559       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
57560     } catch (std::out_of_range& e) {
57561       {
57562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57563       };
57564     } catch (std::exception& e) {
57565       {
57566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57567       };
57568     } catch (...) {
57569       {
57570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57571       };
57572     }
57573   }
57574   jresult = (int)result;
57575   return jresult;
57576 }
57577
57578
57579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
57580   int jresult ;
57581   int result;
57582
57583   {
57584     try {
57585       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
57586     } catch (std::out_of_range& e) {
57587       {
57588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57589       };
57590     } catch (std::exception& e) {
57591       {
57592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57593       };
57594     } catch (...) {
57595       {
57596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57597       };
57598     }
57599   }
57600   jresult = (int)result;
57601   return jresult;
57602 }
57603
57604
57605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
57606   void * jresult ;
57607   Dali::Toolkit::Builder *result = 0 ;
57608
57609   {
57610     try {
57611       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
57612     } catch (std::out_of_range& e) {
57613       {
57614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57615       };
57616     } catch (std::exception& e) {
57617       {
57618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57619       };
57620     } catch (...) {
57621       {
57622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57623       };
57624     }
57625   }
57626   jresult = (void *)result;
57627   return jresult;
57628 }
57629
57630
57631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
57632   void * jresult ;
57633   Dali::Toolkit::Builder result;
57634
57635   {
57636     try {
57637       result = Dali::Toolkit::Builder::New();
57638     } catch (std::out_of_range& e) {
57639       {
57640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57641       };
57642     } catch (std::exception& e) {
57643       {
57644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57645       };
57646     } catch (...) {
57647       {
57648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57649       };
57650     }
57651   }
57652   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
57653   return jresult;
57654 }
57655
57656
57657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
57658   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57659
57660   arg1 = (Dali::Toolkit::Builder *)jarg1;
57661   {
57662     try {
57663       delete arg1;
57664     } catch (std::out_of_range& e) {
57665       {
57666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57667       };
57668     } catch (std::exception& e) {
57669       {
57670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57671       };
57672     } catch (...) {
57673       {
57674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57675       };
57676     }
57677   }
57678 }
57679
57680
57681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
57682   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57683   std::string *arg2 = 0 ;
57684   Dali::Toolkit::Builder::UIFormat arg3 ;
57685
57686   arg1 = (Dali::Toolkit::Builder *)jarg1;
57687   if (!jarg2) {
57688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57689     return ;
57690   }
57691   std::string arg2_str(jarg2);
57692   arg2 = &arg2_str;
57693   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
57694   {
57695     try {
57696       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
57697     } catch (std::out_of_range& e) {
57698       {
57699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57700       };
57701     } catch (std::exception& e) {
57702       {
57703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57704       };
57705     } catch (...) {
57706       {
57707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57708       };
57709     }
57710   }
57711
57712   //argout typemap for const std::string&
57713
57714 }
57715
57716
57717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
57718   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57719   std::string *arg2 = 0 ;
57720
57721   arg1 = (Dali::Toolkit::Builder *)jarg1;
57722   if (!jarg2) {
57723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57724     return ;
57725   }
57726   std::string arg2_str(jarg2);
57727   arg2 = &arg2_str;
57728   {
57729     try {
57730       (arg1)->LoadFromString((std::string const &)*arg2);
57731     } catch (std::out_of_range& e) {
57732       {
57733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57734       };
57735     } catch (std::exception& e) {
57736       {
57737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57738       };
57739     } catch (...) {
57740       {
57741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57742       };
57743     }
57744   }
57745
57746   //argout typemap for const std::string&
57747
57748 }
57749
57750
57751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
57752   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57753   Dali::Property::Map *arg2 = 0 ;
57754
57755   arg1 = (Dali::Toolkit::Builder *)jarg1;
57756   arg2 = (Dali::Property::Map *)jarg2;
57757   if (!arg2) {
57758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57759     return ;
57760   }
57761   {
57762     try {
57763       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
57764     } catch (std::out_of_range& e) {
57765       {
57766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57767       };
57768     } catch (std::exception& e) {
57769       {
57770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57771       };
57772     } catch (...) {
57773       {
57774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57775       };
57776     }
57777   }
57778 }
57779
57780
57781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
57782   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57783   std::string *arg2 = 0 ;
57784   Dali::Property::Value *arg3 = 0 ;
57785
57786   arg1 = (Dali::Toolkit::Builder *)jarg1;
57787   if (!jarg2) {
57788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57789     return ;
57790   }
57791   std::string arg2_str(jarg2);
57792   arg2 = &arg2_str;
57793   arg3 = (Dali::Property::Value *)jarg3;
57794   if (!arg3) {
57795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
57796     return ;
57797   }
57798   {
57799     try {
57800       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
57801     } catch (std::out_of_range& e) {
57802       {
57803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57804       };
57805     } catch (std::exception& e) {
57806       {
57807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57808       };
57809     } catch (...) {
57810       {
57811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57812       };
57813     }
57814   }
57815
57816   //argout typemap for const std::string&
57817
57818 }
57819
57820
57821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
57822   void * jresult ;
57823   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57824   Dali::Property::Map *result = 0 ;
57825
57826   arg1 = (Dali::Toolkit::Builder *)jarg1;
57827   {
57828     try {
57829       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
57830     } catch (std::out_of_range& e) {
57831       {
57832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57833       };
57834     } catch (std::exception& e) {
57835       {
57836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57837       };
57838     } catch (...) {
57839       {
57840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57841       };
57842     }
57843   }
57844   jresult = (void *)result;
57845   return jresult;
57846 }
57847
57848
57849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
57850   void * jresult ;
57851   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57852   std::string *arg2 = 0 ;
57853   Dali::Property::Value *result = 0 ;
57854
57855   arg1 = (Dali::Toolkit::Builder *)jarg1;
57856   if (!jarg2) {
57857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57858     return 0;
57859   }
57860   std::string arg2_str(jarg2);
57861   arg2 = &arg2_str;
57862   {
57863     try {
57864       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
57865     } catch (std::out_of_range& e) {
57866       {
57867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57868       };
57869     } catch (std::exception& e) {
57870       {
57871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57872       };
57873     } catch (...) {
57874       {
57875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57876       };
57877     }
57878   }
57879   jresult = (void *)result;
57880
57881   //argout typemap for const std::string&
57882
57883   return jresult;
57884 }
57885
57886
57887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
57888   void * jresult ;
57889   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57890   std::string *arg2 = 0 ;
57891   Dali::Animation result;
57892
57893   arg1 = (Dali::Toolkit::Builder *)jarg1;
57894   if (!jarg2) {
57895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57896     return 0;
57897   }
57898   std::string arg2_str(jarg2);
57899   arg2 = &arg2_str;
57900   {
57901     try {
57902       result = (arg1)->CreateAnimation((std::string const &)*arg2);
57903     } catch (std::out_of_range& e) {
57904       {
57905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57906       };
57907     } catch (std::exception& e) {
57908       {
57909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57910       };
57911     } catch (...) {
57912       {
57913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57914       };
57915     }
57916   }
57917   jresult = new Dali::Animation((const Dali::Animation &)result);
57918
57919   //argout typemap for const std::string&
57920
57921   return jresult;
57922 }
57923
57924
57925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57926   void * jresult ;
57927   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57928   std::string *arg2 = 0 ;
57929   Dali::Property::Map *arg3 = 0 ;
57930   Dali::Animation result;
57931
57932   arg1 = (Dali::Toolkit::Builder *)jarg1;
57933   if (!jarg2) {
57934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57935     return 0;
57936   }
57937   std::string arg2_str(jarg2);
57938   arg2 = &arg2_str;
57939   arg3 = (Dali::Property::Map *)jarg3;
57940   if (!arg3) {
57941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57942     return 0;
57943   }
57944   {
57945     try {
57946       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
57947     } catch (std::out_of_range& e) {
57948       {
57949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57950       };
57951     } catch (std::exception& e) {
57952       {
57953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57954       };
57955     } catch (...) {
57956       {
57957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57958       };
57959     }
57960   }
57961   jresult = new Dali::Animation((const Dali::Animation &)result);
57962
57963   //argout typemap for const std::string&
57964
57965   return jresult;
57966 }
57967
57968
57969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
57970   void * jresult ;
57971   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57972   std::string *arg2 = 0 ;
57973   Dali::Actor arg3 ;
57974   Dali::Actor *argp3 ;
57975   Dali::Animation result;
57976
57977   arg1 = (Dali::Toolkit::Builder *)jarg1;
57978   if (!jarg2) {
57979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57980     return 0;
57981   }
57982   std::string arg2_str(jarg2);
57983   arg2 = &arg2_str;
57984   argp3 = (Dali::Actor *)jarg3;
57985   if (!argp3) {
57986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57987     return 0;
57988   }
57989   arg3 = *argp3;
57990   {
57991     try {
57992       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
57993     } catch (std::out_of_range& e) {
57994       {
57995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57996       };
57997     } catch (std::exception& e) {
57998       {
57999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58000       };
58001     } catch (...) {
58002       {
58003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58004       };
58005     }
58006   }
58007   jresult = new Dali::Animation((const Dali::Animation &)result);
58008
58009   //argout typemap for const std::string&
58010
58011   return jresult;
58012 }
58013
58014
58015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
58016   void * jresult ;
58017   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58018   std::string *arg2 = 0 ;
58019   Dali::Property::Map *arg3 = 0 ;
58020   Dali::Actor arg4 ;
58021   Dali::Actor *argp4 ;
58022   Dali::Animation result;
58023
58024   arg1 = (Dali::Toolkit::Builder *)jarg1;
58025   if (!jarg2) {
58026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58027     return 0;
58028   }
58029   std::string arg2_str(jarg2);
58030   arg2 = &arg2_str;
58031   arg3 = (Dali::Property::Map *)jarg3;
58032   if (!arg3) {
58033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58034     return 0;
58035   }
58036   argp4 = (Dali::Actor *)jarg4;
58037   if (!argp4) {
58038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58039     return 0;
58040   }
58041   arg4 = *argp4;
58042   {
58043     try {
58044       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
58045     } catch (std::out_of_range& e) {
58046       {
58047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58048       };
58049     } catch (std::exception& e) {
58050       {
58051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58052       };
58053     } catch (...) {
58054       {
58055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58056       };
58057     }
58058   }
58059   jresult = new Dali::Animation((const Dali::Animation &)result);
58060
58061   //argout typemap for const std::string&
58062
58063   return jresult;
58064 }
58065
58066
58067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
58068   void * jresult ;
58069   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58070   std::string *arg2 = 0 ;
58071   Dali::BaseHandle result;
58072
58073   arg1 = (Dali::Toolkit::Builder *)jarg1;
58074   if (!jarg2) {
58075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58076     return 0;
58077   }
58078   std::string arg2_str(jarg2);
58079   arg2 = &arg2_str;
58080   {
58081     try {
58082       result = (arg1)->Create((std::string const &)*arg2);
58083     } catch (std::out_of_range& e) {
58084       {
58085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58086       };
58087     } catch (std::exception& e) {
58088       {
58089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58090       };
58091     } catch (...) {
58092       {
58093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58094       };
58095     }
58096   }
58097   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58098
58099   //argout typemap for const std::string&
58100
58101   return jresult;
58102 }
58103
58104
58105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58106   void * jresult ;
58107   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58108   std::string *arg2 = 0 ;
58109   Dali::Property::Map *arg3 = 0 ;
58110   Dali::BaseHandle result;
58111
58112   arg1 = (Dali::Toolkit::Builder *)jarg1;
58113   if (!jarg2) {
58114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58115     return 0;
58116   }
58117   std::string arg2_str(jarg2);
58118   arg2 = &arg2_str;
58119   arg3 = (Dali::Property::Map *)jarg3;
58120   if (!arg3) {
58121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58122     return 0;
58123   }
58124   {
58125     try {
58126       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
58127     } catch (std::out_of_range& e) {
58128       {
58129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58130       };
58131     } catch (std::exception& e) {
58132       {
58133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58134       };
58135     } catch (...) {
58136       {
58137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58138       };
58139     }
58140   }
58141   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58142
58143   //argout typemap for const std::string&
58144
58145   return jresult;
58146 }
58147
58148
58149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
58150   void * jresult ;
58151   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58152   std::string *arg2 = 0 ;
58153   Dali::BaseHandle result;
58154
58155   arg1 = (Dali::Toolkit::Builder *)jarg1;
58156   if (!jarg2) {
58157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58158     return 0;
58159   }
58160   std::string arg2_str(jarg2);
58161   arg2 = &arg2_str;
58162   {
58163     try {
58164       result = (arg1)->CreateFromJson((std::string const &)*arg2);
58165     } catch (std::out_of_range& e) {
58166       {
58167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58168       };
58169     } catch (std::exception& e) {
58170       {
58171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58172       };
58173     } catch (...) {
58174       {
58175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58176       };
58177     }
58178   }
58179   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58180
58181   //argout typemap for const std::string&
58182
58183   return jresult;
58184 }
58185
58186
58187 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
58188   unsigned int jresult ;
58189   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58190   std::string *arg2 = 0 ;
58191   Dali::Handle *arg3 = 0 ;
58192   bool result;
58193
58194   arg1 = (Dali::Toolkit::Builder *)jarg1;
58195   if (!jarg2) {
58196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58197     return 0;
58198   }
58199   std::string arg2_str(jarg2);
58200   arg2 = &arg2_str;
58201   arg3 = (Dali::Handle *)jarg3;
58202   if (!arg3) {
58203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
58204     return 0;
58205   }
58206   {
58207     try {
58208       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
58209     } catch (std::out_of_range& e) {
58210       {
58211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58212       };
58213     } catch (std::exception& e) {
58214       {
58215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58216       };
58217     } catch (...) {
58218       {
58219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58220       };
58221     }
58222   }
58223   jresult = result;
58224
58225   //argout typemap for const std::string&
58226
58227   return jresult;
58228 }
58229
58230
58231 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
58232   unsigned int jresult ;
58233   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58234   Dali::Handle *arg2 = 0 ;
58235   std::string *arg3 = 0 ;
58236   bool result;
58237
58238   arg1 = (Dali::Toolkit::Builder *)jarg1;
58239   arg2 = (Dali::Handle *)jarg2;
58240   if (!arg2) {
58241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
58242     return 0;
58243   }
58244   if (!jarg3) {
58245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58246     return 0;
58247   }
58248   std::string arg3_str(jarg3);
58249   arg3 = &arg3_str;
58250   {
58251     try {
58252       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
58253     } catch (std::out_of_range& e) {
58254       {
58255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58256       };
58257     } catch (std::exception& e) {
58258       {
58259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58260       };
58261     } catch (...) {
58262       {
58263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58264       };
58265     }
58266   }
58267   jresult = result;
58268
58269   //argout typemap for const std::string&
58270
58271   return jresult;
58272 }
58273
58274
58275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
58276   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58277   Dali::Actor arg2 ;
58278   Dali::Actor *argp2 ;
58279
58280   arg1 = (Dali::Toolkit::Builder *)jarg1;
58281   argp2 = (Dali::Actor *)jarg2;
58282   if (!argp2) {
58283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58284     return ;
58285   }
58286   arg2 = *argp2;
58287   {
58288     try {
58289       (arg1)->AddActors(arg2);
58290     } catch (std::out_of_range& e) {
58291       {
58292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58293       };
58294     } catch (std::exception& e) {
58295       {
58296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58297       };
58298     } catch (...) {
58299       {
58300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58301       };
58302     }
58303   }
58304 }
58305
58306
58307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58308   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58309   std::string *arg2 = 0 ;
58310   Dali::Actor arg3 ;
58311   Dali::Actor *argp3 ;
58312
58313   arg1 = (Dali::Toolkit::Builder *)jarg1;
58314   if (!jarg2) {
58315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58316     return ;
58317   }
58318   std::string arg2_str(jarg2);
58319   arg2 = &arg2_str;
58320   argp3 = (Dali::Actor *)jarg3;
58321   if (!argp3) {
58322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58323     return ;
58324   }
58325   arg3 = *argp3;
58326   {
58327     try {
58328       (arg1)->AddActors((std::string const &)*arg2,arg3);
58329     } catch (std::out_of_range& e) {
58330       {
58331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58332       };
58333     } catch (std::exception& e) {
58334       {
58335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58336       };
58337     } catch (...) {
58338       {
58339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58340       };
58341     }
58342   }
58343
58344   //argout typemap for const std::string&
58345
58346 }
58347
58348
58349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
58350   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58351   std::string *arg2 = 0 ;
58352
58353   arg1 = (Dali::Toolkit::Builder *)jarg1;
58354   if (!jarg2) {
58355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58356     return ;
58357   }
58358   std::string arg2_str(jarg2);
58359   arg2 = &arg2_str;
58360   {
58361     try {
58362       (arg1)->CreateRenderTask((std::string const &)*arg2);
58363     } catch (std::out_of_range& e) {
58364       {
58365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58366       };
58367     } catch (std::exception& e) {
58368       {
58369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58370       };
58371     } catch (...) {
58372       {
58373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58374       };
58375     }
58376   }
58377
58378   //argout typemap for const std::string&
58379
58380 }
58381
58382
58383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
58384   void * jresult ;
58385   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58386   std::string *arg2 = 0 ;
58387   Dali::FrameBufferImage result;
58388
58389   arg1 = (Dali::Toolkit::Builder *)jarg1;
58390   if (!jarg2) {
58391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58392     return 0;
58393   }
58394   std::string arg2_str(jarg2);
58395   arg2 = &arg2_str;
58396   {
58397     try {
58398       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
58399     } catch (std::out_of_range& e) {
58400       {
58401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58402       };
58403     } catch (std::exception& e) {
58404       {
58405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58406       };
58407     } catch (...) {
58408       {
58409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58410       };
58411     }
58412   }
58413   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
58414
58415   //argout typemap for const std::string&
58416
58417   return jresult;
58418 }
58419
58420
58421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
58422   void * jresult ;
58423   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58424   std::string *arg2 = 0 ;
58425   Dali::Path result;
58426
58427   arg1 = (Dali::Toolkit::Builder *)jarg1;
58428   if (!jarg2) {
58429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58430     return 0;
58431   }
58432   std::string arg2_str(jarg2);
58433   arg2 = &arg2_str;
58434   {
58435     try {
58436       result = (arg1)->GetPath((std::string const &)*arg2);
58437     } catch (std::out_of_range& e) {
58438       {
58439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58440       };
58441     } catch (std::exception& e) {
58442       {
58443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58444       };
58445     } catch (...) {
58446       {
58447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58448       };
58449     }
58450   }
58451   jresult = new Dali::Path((const Dali::Path &)result);
58452
58453   //argout typemap for const std::string&
58454
58455   return jresult;
58456 }
58457
58458
58459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
58460   void * jresult ;
58461   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58462   std::string *arg2 = 0 ;
58463   Dali::PathConstrainer result;
58464
58465   arg1 = (Dali::Toolkit::Builder *)jarg1;
58466   if (!jarg2) {
58467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58468     return 0;
58469   }
58470   std::string arg2_str(jarg2);
58471   arg2 = &arg2_str;
58472   {
58473     try {
58474       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
58475     } catch (std::out_of_range& e) {
58476       {
58477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58478       };
58479     } catch (std::exception& e) {
58480       {
58481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58482       };
58483     } catch (...) {
58484       {
58485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58486       };
58487     }
58488   }
58489   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
58490
58491   //argout typemap for const std::string&
58492
58493   return jresult;
58494 }
58495
58496
58497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
58498   void * jresult ;
58499   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58500   std::string *arg2 = 0 ;
58501   Dali::LinearConstrainer result;
58502
58503   arg1 = (Dali::Toolkit::Builder *)jarg1;
58504   if (!jarg2) {
58505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58506     return 0;
58507   }
58508   std::string arg2_str(jarg2);
58509   arg2 = &arg2_str;
58510   {
58511     try {
58512       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
58513     } catch (std::out_of_range& e) {
58514       {
58515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58516       };
58517     } catch (std::exception& e) {
58518       {
58519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58520       };
58521     } catch (...) {
58522       {
58523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58524       };
58525     }
58526   }
58527   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
58528
58529   //argout typemap for const std::string&
58530
58531   return jresult;
58532 }
58533
58534
58535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
58536   void * jresult ;
58537   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58538   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
58539
58540   arg1 = (Dali::Toolkit::Builder *)jarg1;
58541   {
58542     try {
58543       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
58544     } catch (std::out_of_range& e) {
58545       {
58546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58547       };
58548     } catch (std::exception& e) {
58549       {
58550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58551       };
58552     } catch (...) {
58553       {
58554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58555       };
58556     }
58557   }
58558   jresult = (void *)result;
58559   return jresult;
58560 }
58561
58562
58563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
58564   void * jresult ;
58565   Dali::Toolkit::TransitionData *result = 0 ;
58566
58567   {
58568     try {
58569       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
58570     } catch (std::out_of_range& e) {
58571       {
58572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58573       };
58574     } catch (std::exception& e) {
58575       {
58576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58577       };
58578     } catch (...) {
58579       {
58580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58581       };
58582     }
58583   }
58584   jresult = (void *)result;
58585   return jresult;
58586 }
58587
58588
58589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
58590   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58591
58592   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58593   {
58594     try {
58595       delete arg1;
58596     } catch (std::out_of_range& e) {
58597       {
58598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58599       };
58600     } catch (std::exception& e) {
58601       {
58602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58603       };
58604     } catch (...) {
58605       {
58606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58607       };
58608     }
58609   }
58610 }
58611
58612
58613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
58614   void * jresult ;
58615   Dali::Property::Map *arg1 = 0 ;
58616   Dali::Toolkit::TransitionData result;
58617
58618   arg1 = (Dali::Property::Map *)jarg1;
58619   if (!arg1) {
58620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58621     return 0;
58622   }
58623   {
58624     try {
58625       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
58626     } catch (std::out_of_range& e) {
58627       {
58628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58629       };
58630     } catch (std::exception& e) {
58631       {
58632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58633       };
58634     } catch (...) {
58635       {
58636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58637       };
58638     }
58639   }
58640   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58641   return jresult;
58642 }
58643
58644
58645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
58646   void * jresult ;
58647   Dali::Property::Array *arg1 = 0 ;
58648   Dali::Toolkit::TransitionData result;
58649
58650   arg1 = (Dali::Property::Array *)jarg1;
58651   if (!arg1) {
58652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
58653     return 0;
58654   }
58655   {
58656     try {
58657       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
58658     } catch (std::out_of_range& e) {
58659       {
58660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58661       };
58662     } catch (std::exception& e) {
58663       {
58664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58665       };
58666     } catch (...) {
58667       {
58668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58669       };
58670     }
58671   }
58672   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58673   return jresult;
58674 }
58675
58676
58677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
58678   void * jresult ;
58679   Dali::BaseHandle arg1 ;
58680   Dali::BaseHandle *argp1 ;
58681   Dali::Toolkit::TransitionData result;
58682
58683   argp1 = (Dali::BaseHandle *)jarg1;
58684   if (!argp1) {
58685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58686     return 0;
58687   }
58688   arg1 = *argp1;
58689   {
58690     try {
58691       result = Dali::Toolkit::TransitionData::DownCast(arg1);
58692     } catch (std::out_of_range& e) {
58693       {
58694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58695       };
58696     } catch (std::exception& e) {
58697       {
58698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58699       };
58700     } catch (...) {
58701       {
58702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58703       };
58704     }
58705   }
58706   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58707   return jresult;
58708 }
58709
58710
58711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
58712   void * jresult ;
58713   Dali::Toolkit::TransitionData *arg1 = 0 ;
58714   Dali::Toolkit::TransitionData *result = 0 ;
58715
58716   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58717   if (!arg1) {
58718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58719     return 0;
58720   }
58721   {
58722     try {
58723       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
58724     } catch (std::out_of_range& e) {
58725       {
58726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58727       };
58728     } catch (std::exception& e) {
58729       {
58730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58731       };
58732     } catch (...) {
58733       {
58734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58735       };
58736     }
58737   }
58738   jresult = (void *)result;
58739   return jresult;
58740 }
58741
58742
58743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
58744   void * jresult ;
58745   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58746   Dali::Toolkit::TransitionData *arg2 = 0 ;
58747   Dali::Toolkit::TransitionData *result = 0 ;
58748
58749   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58750   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
58751   if (!arg2) {
58752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58753     return 0;
58754   }
58755   {
58756     try {
58757       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
58758     } catch (std::out_of_range& e) {
58759       {
58760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58761       };
58762     } catch (std::exception& e) {
58763       {
58764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58765       };
58766     } catch (...) {
58767       {
58768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58769       };
58770     }
58771   }
58772   jresult = (void *)result;
58773   return jresult;
58774 }
58775
58776
58777 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
58778   unsigned long jresult ;
58779   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58780   size_t result;
58781
58782   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58783   {
58784     try {
58785       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
58786     } catch (std::out_of_range& e) {
58787       {
58788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58789       };
58790     } catch (std::exception& e) {
58791       {
58792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58793       };
58794     } catch (...) {
58795       {
58796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58797       };
58798     }
58799   }
58800   jresult = (unsigned long)result;
58801   return jresult;
58802 }
58803
58804
58805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
58806   void * jresult ;
58807   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58808   size_t arg2 ;
58809   Dali::Property::Map result;
58810
58811   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58812   arg2 = (size_t)jarg2;
58813   {
58814     try {
58815       result = (arg1)->GetAnimatorAt(arg2);
58816     } catch (std::out_of_range& e) {
58817       {
58818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58819       };
58820     } catch (std::exception& e) {
58821       {
58822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58823       };
58824     } catch (...) {
58825       {
58826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58827       };
58828     }
58829   }
58830   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
58831   return jresult;
58832 }
58833
58834
58835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_2(void * jarg1) {
58836   void * jresult ;
58837   Dali::Toolkit::Internal::TransitionData *arg1 = (Dali::Toolkit::Internal::TransitionData *) 0 ;
58838   Dali::Toolkit::TransitionData *result = 0 ;
58839
58840   arg1 = (Dali::Toolkit::Internal::TransitionData *)jarg1;
58841   {
58842     try {
58843       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData(arg1);
58844     } catch (std::out_of_range& e) {
58845       {
58846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58847       };
58848     } catch (std::exception& e) {
58849       {
58850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58851       };
58852     } catch (...) {
58853       {
58854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58855       };
58856     }
58857   }
58858   jresult = (void *)result;
58859   return jresult;
58860 }
58861
58862
58863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
58864   int jresult ;
58865   int result;
58866
58867   {
58868     try {
58869       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
58870     } catch (std::out_of_range& e) {
58871       {
58872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58873       };
58874     } catch (std::exception& e) {
58875       {
58876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58877       };
58878     } catch (...) {
58879       {
58880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58881       };
58882     }
58883   }
58884   jresult = (int)result;
58885   return jresult;
58886 }
58887
58888
58889 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
58890   int jresult ;
58891   int result;
58892
58893   {
58894     try {
58895       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
58896     } catch (std::out_of_range& e) {
58897       {
58898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58899       };
58900     } catch (std::exception& e) {
58901       {
58902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58903       };
58904     } catch (...) {
58905       {
58906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58907       };
58908     }
58909   }
58910   jresult = (int)result;
58911   return jresult;
58912 }
58913
58914
58915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
58916   int jresult ;
58917   int result;
58918
58919   {
58920     try {
58921       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
58922     } catch (std::out_of_range& e) {
58923       {
58924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58925       };
58926     } catch (std::exception& e) {
58927       {
58928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58929       };
58930     } catch (...) {
58931       {
58932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58933       };
58934     }
58935   }
58936   jresult = (int)result;
58937   return jresult;
58938 }
58939
58940
58941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
58942   int jresult ;
58943   int result;
58944
58945   {
58946     try {
58947       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
58948     } catch (std::out_of_range& e) {
58949       {
58950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58951       };
58952     } catch (std::exception& e) {
58953       {
58954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58955       };
58956     } catch (...) {
58957       {
58958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58959       };
58960     }
58961   }
58962   jresult = (int)result;
58963   return jresult;
58964 }
58965
58966
58967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
58968   int jresult ;
58969   int result;
58970
58971   {
58972     try {
58973       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
58974     } catch (std::out_of_range& e) {
58975       {
58976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58977       };
58978     } catch (std::exception& e) {
58979       {
58980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58981       };
58982     } catch (...) {
58983       {
58984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58985       };
58986     }
58987   }
58988   jresult = (int)result;
58989   return jresult;
58990 }
58991
58992
58993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
58994   int jresult ;
58995   int result;
58996
58997   {
58998     try {
58999       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
59000     } catch (std::out_of_range& e) {
59001       {
59002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59003       };
59004     } catch (std::exception& e) {
59005       {
59006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59007       };
59008     } catch (...) {
59009       {
59010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59011       };
59012     }
59013   }
59014   jresult = (int)result;
59015   return jresult;
59016 }
59017
59018
59019 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
59020   int jresult ;
59021   int result;
59022
59023   {
59024     try {
59025       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
59026     } catch (std::out_of_range& e) {
59027       {
59028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59029       };
59030     } catch (std::exception& e) {
59031       {
59032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59033       };
59034     } catch (...) {
59035       {
59036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59037       };
59038     }
59039   }
59040   jresult = (int)result;
59041   return jresult;
59042 }
59043
59044
59045 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
59046   int jresult ;
59047   int result;
59048
59049   {
59050     try {
59051       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
59052     } catch (std::out_of_range& e) {
59053       {
59054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59055       };
59056     } catch (std::exception& e) {
59057       {
59058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59059       };
59060     } catch (...) {
59061       {
59062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59063       };
59064     }
59065   }
59066   jresult = (int)result;
59067   return jresult;
59068 }
59069
59070
59071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
59072   int jresult ;
59073   int result;
59074
59075   {
59076     try {
59077       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
59078     } catch (std::out_of_range& e) {
59079       {
59080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59081       };
59082     } catch (std::exception& e) {
59083       {
59084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59085       };
59086     } catch (...) {
59087       {
59088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59089       };
59090     }
59091   }
59092   jresult = (int)result;
59093   return jresult;
59094 }
59095
59096
59097 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
59098   int jresult ;
59099   int result;
59100
59101   {
59102     try {
59103       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
59104     } catch (std::out_of_range& e) {
59105       {
59106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59107       };
59108     } catch (std::exception& e) {
59109       {
59110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59111       };
59112     } catch (...) {
59113       {
59114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59115       };
59116     }
59117   }
59118   jresult = (int)result;
59119   return jresult;
59120 }
59121
59122
59123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
59124   int jresult ;
59125   int result;
59126
59127   {
59128     try {
59129       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
59130     } catch (std::out_of_range& e) {
59131       {
59132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59133       };
59134     } catch (std::exception& e) {
59135       {
59136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59137       };
59138     } catch (...) {
59139       {
59140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59141       };
59142     }
59143   }
59144   jresult = (int)result;
59145   return jresult;
59146 }
59147
59148
59149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
59150   int jresult ;
59151   int result;
59152
59153   {
59154     try {
59155       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
59156     } catch (std::out_of_range& e) {
59157       {
59158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59159       };
59160     } catch (std::exception& e) {
59161       {
59162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59163       };
59164     } catch (...) {
59165       {
59166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59167       };
59168     }
59169   }
59170   jresult = (int)result;
59171   return jresult;
59172 }
59173
59174
59175 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
59176   int jresult ;
59177   int result;
59178
59179   {
59180     try {
59181       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
59182     } catch (std::out_of_range& e) {
59183       {
59184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59185       };
59186     } catch (std::exception& e) {
59187       {
59188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59189       };
59190     } catch (...) {
59191       {
59192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59193       };
59194     }
59195   }
59196   jresult = (int)result;
59197   return jresult;
59198 }
59199
59200
59201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
59202   int jresult ;
59203   int result;
59204
59205   {
59206     try {
59207       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
59208     } catch (std::out_of_range& e) {
59209       {
59210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59211       };
59212     } catch (std::exception& e) {
59213       {
59214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59215       };
59216     } catch (...) {
59217       {
59218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59219       };
59220     }
59221   }
59222   jresult = (int)result;
59223   return jresult;
59224 }
59225
59226
59227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
59228   void * jresult ;
59229   Dali::Toolkit::Control result;
59230
59231   {
59232     try {
59233       result = Dali::Toolkit::Internal::Control::New();
59234     } catch (std::out_of_range& e) {
59235       {
59236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59237       };
59238     } catch (std::exception& e) {
59239       {
59240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59241       };
59242     } catch (...) {
59243       {
59244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59245       };
59246     }
59247   }
59248   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
59249   return jresult;
59250 }
59251
59252
59253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
59254   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59255   std::string *arg2 = 0 ;
59256
59257   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59258   if (!jarg2) {
59259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59260     return ;
59261   }
59262   std::string arg2_str(jarg2);
59263   arg2 = &arg2_str;
59264   {
59265     try {
59266       (arg1)->SetStyleName((std::string const &)*arg2);
59267     } catch (std::out_of_range& e) {
59268       {
59269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59270       };
59271     } catch (std::exception& e) {
59272       {
59273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59274       };
59275     } catch (...) {
59276       {
59277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59278       };
59279     }
59280   }
59281
59282   //argout typemap for const std::string&
59283
59284 }
59285
59286
59287 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
59288   char * jresult ;
59289   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59290   std::string *result = 0 ;
59291
59292   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59293   {
59294     try {
59295       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
59296     } catch (std::out_of_range& e) {
59297       {
59298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59299       };
59300     } catch (std::exception& e) {
59301       {
59302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59303       };
59304     } catch (...) {
59305       {
59306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59307       };
59308     }
59309   }
59310   jresult = SWIG_csharp_string_callback(result->c_str());
59311   return jresult;
59312 }
59313
59314
59315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
59316   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59317   Dali::Vector4 *arg2 = 0 ;
59318
59319   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59320   arg2 = (Dali::Vector4 *)jarg2;
59321   if (!arg2) {
59322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
59323     return ;
59324   }
59325   {
59326     try {
59327       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
59328     } catch (std::out_of_range& e) {
59329       {
59330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59331       };
59332     } catch (std::exception& e) {
59333       {
59334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59335       };
59336     } catch (...) {
59337       {
59338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59339       };
59340     }
59341   }
59342 }
59343
59344
59345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
59346   void * jresult ;
59347   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59348   Dali::Vector4 result;
59349
59350   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59351   {
59352     try {
59353       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
59354     } catch (std::out_of_range& e) {
59355       {
59356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59357       };
59358     } catch (std::exception& e) {
59359       {
59360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59361       };
59362     } catch (...) {
59363       {
59364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59365       };
59366     }
59367   }
59368   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
59369   return jresult;
59370 }
59371
59372
59373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
59374   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59375   Dali::Image arg2 ;
59376   Dali::Image *argp2 ;
59377
59378   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59379   argp2 = (Dali::Image *)jarg2;
59380   if (!argp2) {
59381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
59382     return ;
59383   }
59384   arg2 = *argp2;
59385   {
59386     try {
59387       (arg1)->SetBackgroundImage(arg2);
59388     } catch (std::out_of_range& e) {
59389       {
59390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59391       };
59392     } catch (std::exception& e) {
59393       {
59394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59395       };
59396     } catch (...) {
59397       {
59398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59399       };
59400     }
59401   }
59402 }
59403
59404
59405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
59406   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59407   Dali::Property::Map *arg2 = 0 ;
59408
59409   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59410   arg2 = (Dali::Property::Map *)jarg2;
59411   if (!arg2) {
59412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59413     return ;
59414   }
59415   {
59416     try {
59417       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
59418     } catch (std::out_of_range& e) {
59419       {
59420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59421       };
59422     } catch (std::exception& e) {
59423       {
59424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59425       };
59426     } catch (...) {
59427       {
59428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59429       };
59430     }
59431   }
59432 }
59433
59434
59435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
59436   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59437
59438   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59439   {
59440     try {
59441       (arg1)->ClearBackground();
59442     } catch (std::out_of_range& e) {
59443       {
59444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59445       };
59446     } catch (std::exception& e) {
59447       {
59448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59449       };
59450     } catch (...) {
59451       {
59452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59453       };
59454     }
59455   }
59456 }
59457
59458
59459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
59460   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59461   Dali::Gesture::Type arg2 ;
59462
59463   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59464   arg2 = (Dali::Gesture::Type)jarg2;
59465   {
59466     try {
59467       (arg1)->EnableGestureDetection(arg2);
59468     } catch (std::out_of_range& e) {
59469       {
59470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59471       };
59472     } catch (std::exception& e) {
59473       {
59474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59475       };
59476     } catch (...) {
59477       {
59478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59479       };
59480     }
59481   }
59482 }
59483
59484
59485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
59486   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59487   Dali::Gesture::Type arg2 ;
59488
59489   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59490   arg2 = (Dali::Gesture::Type)jarg2;
59491   {
59492     try {
59493       (arg1)->DisableGestureDetection(arg2);
59494     } catch (std::out_of_range& e) {
59495       {
59496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59497       };
59498     } catch (std::exception& e) {
59499       {
59500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59501       };
59502     } catch (...) {
59503       {
59504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59505       };
59506     }
59507   }
59508 }
59509
59510
59511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
59512   void * jresult ;
59513   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59514   Dali::PinchGestureDetector result;
59515
59516   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59517   {
59518     try {
59519       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
59520     } catch (std::out_of_range& e) {
59521       {
59522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59523       };
59524     } catch (std::exception& e) {
59525       {
59526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59527       };
59528     } catch (...) {
59529       {
59530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59531       };
59532     }
59533   }
59534   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
59535   return jresult;
59536 }
59537
59538
59539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
59540   void * jresult ;
59541   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59542   Dali::PanGestureDetector result;
59543
59544   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59545   {
59546     try {
59547       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
59548     } catch (std::out_of_range& e) {
59549       {
59550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59551       };
59552     } catch (std::exception& e) {
59553       {
59554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59555       };
59556     } catch (...) {
59557       {
59558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59559       };
59560     }
59561   }
59562   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
59563   return jresult;
59564 }
59565
59566
59567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
59568   void * jresult ;
59569   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59570   Dali::TapGestureDetector result;
59571
59572   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59573   {
59574     try {
59575       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
59576     } catch (std::out_of_range& e) {
59577       {
59578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59579       };
59580     } catch (std::exception& e) {
59581       {
59582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59583       };
59584     } catch (...) {
59585       {
59586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59587       };
59588     }
59589   }
59590   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
59591   return jresult;
59592 }
59593
59594
59595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
59596   void * jresult ;
59597   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59598   Dali::LongPressGestureDetector result;
59599
59600   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59601   {
59602     try {
59603       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
59604     } catch (std::out_of_range& e) {
59605       {
59606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59607       };
59608     } catch (std::exception& e) {
59609       {
59610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59611       };
59612     } catch (...) {
59613       {
59614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59615       };
59616     }
59617   }
59618   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
59619   return jresult;
59620 }
59621
59622
59623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
59624   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59625   bool arg2 ;
59626
59627   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59628   arg2 = jarg2 ? true : false;
59629   {
59630     try {
59631       (arg1)->SetKeyboardNavigationSupport(arg2);
59632     } catch (std::out_of_range& e) {
59633       {
59634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59635       };
59636     } catch (std::exception& e) {
59637       {
59638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59639       };
59640     } catch (...) {
59641       {
59642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59643       };
59644     }
59645   }
59646 }
59647
59648
59649 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
59650   unsigned int jresult ;
59651   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59652   bool result;
59653
59654   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59655   {
59656     try {
59657       result = (bool)(arg1)->IsKeyboardNavigationSupported();
59658     } catch (std::out_of_range& e) {
59659       {
59660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59661       };
59662     } catch (std::exception& e) {
59663       {
59664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59665       };
59666     } catch (...) {
59667       {
59668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59669       };
59670     }
59671   }
59672   jresult = result;
59673   return jresult;
59674 }
59675
59676
59677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
59678   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59679
59680   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59681   {
59682     try {
59683       (arg1)->SetKeyInputFocus();
59684     } catch (std::out_of_range& e) {
59685       {
59686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59687       };
59688     } catch (std::exception& e) {
59689       {
59690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59691       };
59692     } catch (...) {
59693       {
59694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59695       };
59696     }
59697   }
59698 }
59699
59700
59701 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
59702   unsigned int jresult ;
59703   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59704   bool result;
59705
59706   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59707   {
59708     try {
59709       result = (bool)(arg1)->HasKeyInputFocus();
59710     } catch (std::out_of_range& e) {
59711       {
59712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59713       };
59714     } catch (std::exception& e) {
59715       {
59716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59717       };
59718     } catch (...) {
59719       {
59720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59721       };
59722     }
59723   }
59724   jresult = result;
59725   return jresult;
59726 }
59727
59728
59729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
59730   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59731
59732   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59733   {
59734     try {
59735       (arg1)->ClearKeyInputFocus();
59736     } catch (std::out_of_range& e) {
59737       {
59738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59739       };
59740     } catch (std::exception& e) {
59741       {
59742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59743       };
59744     } catch (...) {
59745       {
59746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59747       };
59748     }
59749   }
59750 }
59751
59752
59753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
59754   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59755   bool arg2 ;
59756
59757   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59758   arg2 = jarg2 ? true : false;
59759   {
59760     try {
59761       (arg1)->SetAsKeyboardFocusGroup(arg2);
59762     } catch (std::out_of_range& e) {
59763       {
59764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59765       };
59766     } catch (std::exception& e) {
59767       {
59768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59769       };
59770     } catch (...) {
59771       {
59772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59773       };
59774     }
59775   }
59776 }
59777
59778
59779 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
59780   unsigned int jresult ;
59781   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59782   bool result;
59783
59784   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59785   {
59786     try {
59787       result = (bool)(arg1)->IsKeyboardFocusGroup();
59788     } catch (std::out_of_range& e) {
59789       {
59790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59791       };
59792     } catch (std::exception& e) {
59793       {
59794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59795       };
59796     } catch (...) {
59797       {
59798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59799       };
59800     }
59801   }
59802   jresult = result;
59803   return jresult;
59804 }
59805
59806
59807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_AccessibilityActivate(void * jarg1) {
59808   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59809
59810   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59811   {
59812     try {
59813       (arg1)->AccessibilityActivate();
59814     } catch (std::out_of_range& e) {
59815       {
59816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59817       };
59818     } catch (std::exception& e) {
59819       {
59820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59821       };
59822     } catch (...) {
59823       {
59824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59825       };
59826     }
59827   }
59828 }
59829
59830
59831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_KeyboardEnter(void * jarg1) {
59832   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59833
59834   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59835   {
59836     try {
59837       (arg1)->KeyboardEnter();
59838     } catch (std::out_of_range& e) {
59839       {
59840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59841       };
59842     } catch (std::exception& e) {
59843       {
59844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59845       };
59846     } catch (...) {
59847       {
59848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59849       };
59850     }
59851   }
59852 }
59853
59854
59855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
59856   void * jresult ;
59857   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59858   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
59859
59860   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59861   {
59862     try {
59863       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
59864     } catch (std::out_of_range& e) {
59865       {
59866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59867       };
59868     } catch (std::exception& e) {
59869       {
59870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59871       };
59872     } catch (...) {
59873       {
59874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59875       };
59876     }
59877   }
59878   jresult = (void *)result;
59879   return jresult;
59880 }
59881
59882
59883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
59884   void * jresult ;
59885   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59886   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59887
59888   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59889   {
59890     try {
59891       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
59892     } catch (std::out_of_range& e) {
59893       {
59894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59895       };
59896     } catch (std::exception& e) {
59897       {
59898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59899       };
59900     } catch (...) {
59901       {
59902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59903       };
59904     }
59905   }
59906   jresult = (void *)result;
59907   return jresult;
59908 }
59909
59910
59911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
59912   void * jresult ;
59913   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59914   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59915
59916   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59917   {
59918     try {
59919       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
59920     } catch (std::out_of_range& e) {
59921       {
59922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59923       };
59924     } catch (std::exception& e) {
59925       {
59926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59927       };
59928     } catch (...) {
59929       {
59930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59931       };
59932     }
59933   }
59934   jresult = (void *)result;
59935   return jresult;
59936 }
59937
59938
59939 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_EmitKeyEventSignal(void * jarg1, void * jarg2) {
59940   unsigned int jresult ;
59941   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59942   Dali::KeyEvent *arg2 = 0 ;
59943   bool result;
59944
59945   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59946   arg2 = (Dali::KeyEvent *)jarg2;
59947   if (!arg2) {
59948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
59949     return 0;
59950   }
59951   {
59952     try {
59953       result = (bool)(arg1)->EmitKeyEventSignal((Dali::KeyEvent const &)*arg2);
59954     } catch (std::out_of_range& e) {
59955       {
59956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59957       };
59958     } catch (std::exception& e) {
59959       {
59960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59961       };
59962     } catch (...) {
59963       {
59964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59965       };
59966     }
59967   }
59968   jresult = result;
59969   return jresult;
59970 }
59971
59972
59973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
59974   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59975   int arg2 ;
59976   SwigDirector_ViewImpl *darg = 0;
59977
59978   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59979   arg2 = (int)jarg2;
59980   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59981   {
59982     try {
59983       (darg)->OnStageConnection(arg2);
59984     } catch (std::out_of_range& e) {
59985       {
59986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59987       };
59988     } catch (std::exception& e) {
59989       {
59990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59991       };
59992     } catch (...) {
59993       {
59994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59995       };
59996     }
59997   }
59998 }
59999
60000
60001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
60002   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60003   int arg2 ;
60004   SwigDirector_ViewImpl *darg = 0;
60005
60006   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60007   arg2 = (int)jarg2;
60008   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60009   {
60010     try {
60011       (darg)->OnStageConnectionSwigPublic(arg2);
60012     } catch (std::out_of_range& e) {
60013       {
60014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60015       };
60016     } catch (std::exception& e) {
60017       {
60018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60019       };
60020     } catch (...) {
60021       {
60022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60023       };
60024     }
60025   }
60026 }
60027
60028
60029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
60030   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60031   SwigDirector_ViewImpl *darg = 0;
60032
60033   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60034   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60035   {
60036     try {
60037       (darg)->OnStageDisconnection();
60038     } catch (std::out_of_range& e) {
60039       {
60040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60041       };
60042     } catch (std::exception& e) {
60043       {
60044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60045       };
60046     } catch (...) {
60047       {
60048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60049       };
60050     }
60051   }
60052 }
60053
60054
60055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
60056   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60057   SwigDirector_ViewImpl *darg = 0;
60058
60059   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60060   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60061   {
60062     try {
60063       (darg)->OnStageDisconnectionSwigPublic();
60064     } catch (std::out_of_range& e) {
60065       {
60066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60067       };
60068     } catch (std::exception& e) {
60069       {
60070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60071       };
60072     } catch (...) {
60073       {
60074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60075       };
60076     }
60077   }
60078 }
60079
60080
60081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
60082   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60083   Dali::Actor *arg2 = 0 ;
60084   SwigDirector_ViewImpl *darg = 0;
60085
60086   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60087   arg2 = (Dali::Actor *)jarg2;
60088   if (!arg2) {
60089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60090     return ;
60091   }
60092   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60093   {
60094     try {
60095       (darg)->OnChildAdd(*arg2);
60096     } catch (std::out_of_range& e) {
60097       {
60098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60099       };
60100     } catch (std::exception& e) {
60101       {
60102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60103       };
60104     } catch (...) {
60105       {
60106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60107       };
60108     }
60109   }
60110 }
60111
60112
60113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60114   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60115   Dali::Actor *arg2 = 0 ;
60116   SwigDirector_ViewImpl *darg = 0;
60117
60118   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60119   arg2 = (Dali::Actor *)jarg2;
60120   if (!arg2) {
60121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60122     return ;
60123   }
60124   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60125   {
60126     try {
60127       (darg)->OnChildAddSwigPublic(*arg2);
60128     } catch (std::out_of_range& e) {
60129       {
60130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60131       };
60132     } catch (std::exception& e) {
60133       {
60134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60135       };
60136     } catch (...) {
60137       {
60138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60139       };
60140     }
60141   }
60142 }
60143
60144
60145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
60146   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60147   Dali::Actor *arg2 = 0 ;
60148   SwigDirector_ViewImpl *darg = 0;
60149
60150   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60151   arg2 = (Dali::Actor *)jarg2;
60152   if (!arg2) {
60153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60154     return ;
60155   }
60156   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60157   {
60158     try {
60159       (darg)->OnChildRemove(*arg2);
60160     } catch (std::out_of_range& e) {
60161       {
60162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60163       };
60164     } catch (std::exception& e) {
60165       {
60166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60167       };
60168     } catch (...) {
60169       {
60170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60171       };
60172     }
60173   }
60174 }
60175
60176
60177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60178   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60179   Dali::Actor *arg2 = 0 ;
60180   SwigDirector_ViewImpl *darg = 0;
60181
60182   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60183   arg2 = (Dali::Actor *)jarg2;
60184   if (!arg2) {
60185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60186     return ;
60187   }
60188   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60189   {
60190     try {
60191       (darg)->OnChildRemoveSwigPublic(*arg2);
60192     } catch (std::out_of_range& e) {
60193       {
60194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60195       };
60196     } catch (std::exception& e) {
60197       {
60198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60199       };
60200     } catch (...) {
60201       {
60202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60203       };
60204     }
60205   }
60206 }
60207
60208
60209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
60210   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60211   Dali::Property::Index arg2 ;
60212   Dali::Property::Value arg3 ;
60213   Dali::Property::Value *argp3 ;
60214   SwigDirector_ViewImpl *darg = 0;
60215
60216   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60217   arg2 = (Dali::Property::Index)jarg2;
60218   argp3 = (Dali::Property::Value *)jarg3;
60219   if (!argp3) {
60220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60221     return ;
60222   }
60223   arg3 = *argp3;
60224   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60225   {
60226     try {
60227       (darg)->OnPropertySet(arg2,arg3);
60228     } catch (std::out_of_range& e) {
60229       {
60230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60231       };
60232     } catch (std::exception& e) {
60233       {
60234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60235       };
60236     } catch (...) {
60237       {
60238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60239       };
60240     }
60241   }
60242 }
60243
60244
60245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
60246   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60247   Dali::Property::Index arg2 ;
60248   Dali::Property::Value arg3 ;
60249   Dali::Property::Value *argp3 ;
60250   SwigDirector_ViewImpl *darg = 0;
60251
60252   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60253   arg2 = (Dali::Property::Index)jarg2;
60254   argp3 = (Dali::Property::Value *)jarg3;
60255   if (!argp3) {
60256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60257     return ;
60258   }
60259   arg3 = *argp3;
60260   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60261   {
60262     try {
60263       (darg)->OnPropertySetSwigPublic(arg2,arg3);
60264     } catch (std::out_of_range& e) {
60265       {
60266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60267       };
60268     } catch (std::exception& e) {
60269       {
60270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60271       };
60272     } catch (...) {
60273       {
60274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60275       };
60276     }
60277   }
60278 }
60279
60280
60281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
60282   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60283   Dali::Vector3 *arg2 = 0 ;
60284   SwigDirector_ViewImpl *darg = 0;
60285
60286   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60287   arg2 = (Dali::Vector3 *)jarg2;
60288   if (!arg2) {
60289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60290     return ;
60291   }
60292   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60293   {
60294     try {
60295       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
60296     } catch (std::out_of_range& e) {
60297       {
60298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60299       };
60300     } catch (std::exception& e) {
60301       {
60302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60303       };
60304     } catch (...) {
60305       {
60306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60307       };
60308     }
60309   }
60310 }
60311
60312
60313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60314   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60315   Dali::Vector3 *arg2 = 0 ;
60316   SwigDirector_ViewImpl *darg = 0;
60317
60318   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60319   arg2 = (Dali::Vector3 *)jarg2;
60320   if (!arg2) {
60321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60322     return ;
60323   }
60324   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60325   {
60326     try {
60327       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
60328     } catch (std::out_of_range& e) {
60329       {
60330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60331       };
60332     } catch (std::exception& e) {
60333       {
60334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60335       };
60336     } catch (...) {
60337       {
60338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60339       };
60340     }
60341   }
60342 }
60343
60344
60345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
60346   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60347   Dali::Animation *arg2 = 0 ;
60348   Dali::Vector3 *arg3 = 0 ;
60349   SwigDirector_ViewImpl *darg = 0;
60350
60351   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60352   arg2 = (Dali::Animation *)jarg2;
60353   if (!arg2) {
60354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60355     return ;
60356   }
60357   arg3 = (Dali::Vector3 *)jarg3;
60358   if (!arg3) {
60359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60360     return ;
60361   }
60362   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60363   {
60364     try {
60365       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
60366     } catch (std::out_of_range& e) {
60367       {
60368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60369       };
60370     } catch (std::exception& e) {
60371       {
60372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60373       };
60374     } catch (...) {
60375       {
60376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60377       };
60378     }
60379   }
60380 }
60381
60382
60383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60384   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60385   Dali::Animation *arg2 = 0 ;
60386   Dali::Vector3 *arg3 = 0 ;
60387   SwigDirector_ViewImpl *darg = 0;
60388
60389   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60390   arg2 = (Dali::Animation *)jarg2;
60391   if (!arg2) {
60392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60393     return ;
60394   }
60395   arg3 = (Dali::Vector3 *)jarg3;
60396   if (!arg3) {
60397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60398     return ;
60399   }
60400   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60401   {
60402     try {
60403       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
60404     } catch (std::out_of_range& e) {
60405       {
60406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60407       };
60408     } catch (std::exception& e) {
60409       {
60410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60411       };
60412     } catch (...) {
60413       {
60414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60415       };
60416     }
60417   }
60418 }
60419
60420
60421 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
60422   unsigned int jresult ;
60423   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60424   Dali::TouchEvent *arg2 = 0 ;
60425   SwigDirector_ViewImpl *darg = 0;
60426   bool result;
60427
60428   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60429   arg2 = (Dali::TouchEvent *)jarg2;
60430   if (!arg2) {
60431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
60432     return 0;
60433   }
60434   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60435   {
60436     try {
60437       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
60438     } catch (std::out_of_range& e) {
60439       {
60440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60441       };
60442     } catch (std::exception& e) {
60443       {
60444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60445       };
60446     } catch (...) {
60447       {
60448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60449       };
60450     }
60451   }
60452   jresult = result;
60453   return jresult;
60454 }
60455
60456
60457 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60458   unsigned int jresult ;
60459   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60460   Dali::TouchEvent *arg2 = 0 ;
60461   SwigDirector_ViewImpl *darg = 0;
60462   bool result;
60463
60464   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60465   arg2 = (Dali::TouchEvent *)jarg2;
60466   if (!arg2) {
60467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
60468     return 0;
60469   }
60470   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60471   {
60472     try {
60473       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
60474     } catch (std::out_of_range& e) {
60475       {
60476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60477       };
60478     } catch (std::exception& e) {
60479       {
60480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60481       };
60482     } catch (...) {
60483       {
60484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60485       };
60486     }
60487   }
60488   jresult = result;
60489   return jresult;
60490 }
60491
60492
60493 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
60494   unsigned int jresult ;
60495   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60496   Dali::HoverEvent *arg2 = 0 ;
60497   SwigDirector_ViewImpl *darg = 0;
60498   bool result;
60499
60500   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60501   arg2 = (Dali::HoverEvent *)jarg2;
60502   if (!arg2) {
60503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60504     return 0;
60505   }
60506   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60507   {
60508     try {
60509       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
60510     } catch (std::out_of_range& e) {
60511       {
60512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60513       };
60514     } catch (std::exception& e) {
60515       {
60516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60517       };
60518     } catch (...) {
60519       {
60520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60521       };
60522     }
60523   }
60524   jresult = result;
60525   return jresult;
60526 }
60527
60528
60529 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60530   unsigned int jresult ;
60531   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60532   Dali::HoverEvent *arg2 = 0 ;
60533   SwigDirector_ViewImpl *darg = 0;
60534   bool result;
60535
60536   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60537   arg2 = (Dali::HoverEvent *)jarg2;
60538   if (!arg2) {
60539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60540     return 0;
60541   }
60542   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60543   {
60544     try {
60545       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
60546     } catch (std::out_of_range& e) {
60547       {
60548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60549       };
60550     } catch (std::exception& e) {
60551       {
60552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60553       };
60554     } catch (...) {
60555       {
60556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60557       };
60558     }
60559   }
60560   jresult = result;
60561   return jresult;
60562 }
60563
60564
60565 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
60566   unsigned int jresult ;
60567   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60568   Dali::KeyEvent *arg2 = 0 ;
60569   SwigDirector_ViewImpl *darg = 0;
60570   bool result;
60571
60572   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60573   arg2 = (Dali::KeyEvent *)jarg2;
60574   if (!arg2) {
60575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60576     return 0;
60577   }
60578   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60579   {
60580     try {
60581       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
60582     } catch (std::out_of_range& e) {
60583       {
60584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60585       };
60586     } catch (std::exception& e) {
60587       {
60588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60589       };
60590     } catch (...) {
60591       {
60592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60593       };
60594     }
60595   }
60596   jresult = result;
60597   return jresult;
60598 }
60599
60600
60601 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60602   unsigned int jresult ;
60603   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60604   Dali::KeyEvent *arg2 = 0 ;
60605   SwigDirector_ViewImpl *darg = 0;
60606   bool result;
60607
60608   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60609   arg2 = (Dali::KeyEvent *)jarg2;
60610   if (!arg2) {
60611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60612     return 0;
60613   }
60614   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60615   {
60616     try {
60617       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
60618     } catch (std::out_of_range& e) {
60619       {
60620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60621       };
60622     } catch (std::exception& e) {
60623       {
60624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60625       };
60626     } catch (...) {
60627       {
60628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60629       };
60630     }
60631   }
60632   jresult = result;
60633   return jresult;
60634 }
60635
60636
60637 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
60638   unsigned int jresult ;
60639   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60640   Dali::WheelEvent *arg2 = 0 ;
60641   SwigDirector_ViewImpl *darg = 0;
60642   bool result;
60643
60644   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60645   arg2 = (Dali::WheelEvent *)jarg2;
60646   if (!arg2) {
60647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
60648     return 0;
60649   }
60650   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60651   {
60652     try {
60653       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
60654     } catch (std::out_of_range& e) {
60655       {
60656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60657       };
60658     } catch (std::exception& e) {
60659       {
60660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60661       };
60662     } catch (...) {
60663       {
60664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60665       };
60666     }
60667   }
60668   jresult = result;
60669   return jresult;
60670 }
60671
60672
60673 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60674   unsigned int jresult ;
60675   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60676   Dali::WheelEvent *arg2 = 0 ;
60677   SwigDirector_ViewImpl *darg = 0;
60678   bool result;
60679
60680   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60681   arg2 = (Dali::WheelEvent *)jarg2;
60682   if (!arg2) {
60683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
60684     return 0;
60685   }
60686   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60687   {
60688     try {
60689       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
60690     } catch (std::out_of_range& e) {
60691       {
60692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60693       };
60694     } catch (std::exception& e) {
60695       {
60696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60697       };
60698     } catch (...) {
60699       {
60700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60701       };
60702     }
60703   }
60704   jresult = result;
60705   return jresult;
60706 }
60707
60708
60709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
60710   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60711   Dali::Vector2 *arg2 = 0 ;
60712   Dali::RelayoutContainer *arg3 = 0 ;
60713   SwigDirector_ViewImpl *darg = 0;
60714
60715   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60716   arg2 = (Dali::Vector2 *)jarg2;
60717   if (!arg2) {
60718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
60719     return ;
60720   }
60721   arg3 = (Dali::RelayoutContainer *)jarg3;
60722   if (!arg3) {
60723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
60724     return ;
60725   }
60726   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60727   {
60728     try {
60729       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
60730     } catch (std::out_of_range& e) {
60731       {
60732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60733       };
60734     } catch (std::exception& e) {
60735       {
60736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60737       };
60738     } catch (...) {
60739       {
60740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60741       };
60742     }
60743   }
60744 }
60745
60746
60747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60748   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60749   Dali::Vector2 *arg2 = 0 ;
60750   Dali::RelayoutContainer *arg3 = 0 ;
60751   SwigDirector_ViewImpl *darg = 0;
60752
60753   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60754   arg2 = (Dali::Vector2 *)jarg2;
60755   if (!arg2) {
60756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
60757     return ;
60758   }
60759   arg3 = (Dali::RelayoutContainer *)jarg3;
60760   if (!arg3) {
60761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
60762     return ;
60763   }
60764   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60765   {
60766     try {
60767       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
60768     } catch (std::out_of_range& e) {
60769       {
60770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60771       };
60772     } catch (std::exception& e) {
60773       {
60774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60775       };
60776     } catch (...) {
60777       {
60778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60779       };
60780     }
60781   }
60782 }
60783
60784
60785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
60786   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60787   Dali::ResizePolicy::Type arg2 ;
60788   Dali::Dimension::Type arg3 ;
60789   SwigDirector_ViewImpl *darg = 0;
60790
60791   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60792   arg2 = (Dali::ResizePolicy::Type)jarg2;
60793   arg3 = (Dali::Dimension::Type)jarg3;
60794   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60795   {
60796     try {
60797       (darg)->OnSetResizePolicy(arg2,arg3);
60798     } catch (std::out_of_range& e) {
60799       {
60800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60801       };
60802     } catch (std::exception& e) {
60803       {
60804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60805       };
60806     } catch (...) {
60807       {
60808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60809       };
60810     }
60811   }
60812 }
60813
60814
60815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
60816   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60817   Dali::ResizePolicy::Type arg2 ;
60818   Dali::Dimension::Type arg3 ;
60819   SwigDirector_ViewImpl *darg = 0;
60820
60821   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60822   arg2 = (Dali::ResizePolicy::Type)jarg2;
60823   arg3 = (Dali::Dimension::Type)jarg3;
60824   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60825   {
60826     try {
60827       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
60828     } catch (std::out_of_range& e) {
60829       {
60830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60831       };
60832     } catch (std::exception& e) {
60833       {
60834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60835       };
60836     } catch (...) {
60837       {
60838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60839       };
60840     }
60841   }
60842 }
60843
60844
60845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
60846   void * jresult ;
60847   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60848   SwigDirector_ViewImpl *darg = 0;
60849   Dali::Vector3 result;
60850
60851   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60852   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60853   {
60854     try {
60855       result = (darg)->GetNaturalSize();
60856     } catch (std::out_of_range& e) {
60857       {
60858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60859       };
60860     } catch (std::exception& e) {
60861       {
60862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60863       };
60864     } catch (...) {
60865       {
60866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60867       };
60868     }
60869   }
60870   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
60871   return jresult;
60872 }
60873
60874
60875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
60876   void * jresult ;
60877   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60878   SwigDirector_ViewImpl *darg = 0;
60879   Dali::Vector3 result;
60880
60881   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60882   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60883   {
60884     try {
60885       result = (darg)->GetNaturalSizeSwigPublic();
60886     } catch (std::out_of_range& e) {
60887       {
60888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60889       };
60890     } catch (std::exception& e) {
60891       {
60892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60893       };
60894     } catch (...) {
60895       {
60896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60897       };
60898     }
60899   }
60900   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
60901   return jresult;
60902 }
60903
60904
60905 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
60906   float jresult ;
60907   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60908   Dali::Actor *arg2 = 0 ;
60909   Dali::Dimension::Type arg3 ;
60910   SwigDirector_ViewImpl *darg = 0;
60911   float result;
60912
60913   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60914   arg2 = (Dali::Actor *)jarg2;
60915   if (!arg2) {
60916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
60917     return 0;
60918   }
60919   arg3 = (Dali::Dimension::Type)jarg3;
60920   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60921   {
60922     try {
60923       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
60924     } catch (std::out_of_range& e) {
60925       {
60926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60927       };
60928     } catch (std::exception& e) {
60929       {
60930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60931       };
60932     } catch (...) {
60933       {
60934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60935       };
60936     }
60937   }
60938   jresult = result;
60939   return jresult;
60940 }
60941
60942
60943 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
60944   float jresult ;
60945   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60946   Dali::Actor *arg2 = 0 ;
60947   Dali::Dimension::Type arg3 ;
60948   SwigDirector_ViewImpl *darg = 0;
60949   float result;
60950
60951   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60952   arg2 = (Dali::Actor *)jarg2;
60953   if (!arg2) {
60954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
60955     return 0;
60956   }
60957   arg3 = (Dali::Dimension::Type)jarg3;
60958   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60959   {
60960     try {
60961       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
60962     } catch (std::out_of_range& e) {
60963       {
60964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60965       };
60966     } catch (std::exception& e) {
60967       {
60968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60969       };
60970     } catch (...) {
60971       {
60972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60973       };
60974     }
60975   }
60976   jresult = result;
60977   return jresult;
60978 }
60979
60980
60981 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
60982   float jresult ;
60983   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60984   float arg2 ;
60985   SwigDirector_ViewImpl *darg = 0;
60986   float result;
60987
60988   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60989   arg2 = (float)jarg2;
60990   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60991   {
60992     try {
60993       result = (float)(darg)->GetHeightForWidth(arg2);
60994     } catch (std::out_of_range& e) {
60995       {
60996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60997       };
60998     } catch (std::exception& e) {
60999       {
61000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61001       };
61002     } catch (...) {
61003       {
61004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61005       };
61006     }
61007   }
61008   jresult = result;
61009   return jresult;
61010 }
61011
61012
61013 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
61014   float jresult ;
61015   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61016   float arg2 ;
61017   SwigDirector_ViewImpl *darg = 0;
61018   float result;
61019
61020   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61021   arg2 = (float)jarg2;
61022   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61023   {
61024     try {
61025       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
61026     } catch (std::out_of_range& e) {
61027       {
61028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61029       };
61030     } catch (std::exception& e) {
61031       {
61032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61033       };
61034     } catch (...) {
61035       {
61036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61037       };
61038     }
61039   }
61040   jresult = result;
61041   return jresult;
61042 }
61043
61044
61045 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
61046   float jresult ;
61047   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61048   float arg2 ;
61049   SwigDirector_ViewImpl *darg = 0;
61050   float result;
61051
61052   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61053   arg2 = (float)jarg2;
61054   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61055   {
61056     try {
61057       result = (float)(darg)->GetWidthForHeight(arg2);
61058     } catch (std::out_of_range& e) {
61059       {
61060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61061       };
61062     } catch (std::exception& e) {
61063       {
61064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61065       };
61066     } catch (...) {
61067       {
61068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61069       };
61070     }
61071   }
61072   jresult = result;
61073   return jresult;
61074 }
61075
61076
61077 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
61078   float jresult ;
61079   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61080   float arg2 ;
61081   SwigDirector_ViewImpl *darg = 0;
61082   float result;
61083
61084   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61085   arg2 = (float)jarg2;
61086   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61087   {
61088     try {
61089       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
61090     } catch (std::out_of_range& e) {
61091       {
61092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61093       };
61094     } catch (std::exception& e) {
61095       {
61096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61097       };
61098     } catch (...) {
61099       {
61100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61101       };
61102     }
61103   }
61104   jresult = result;
61105   return jresult;
61106 }
61107
61108
61109 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
61110   unsigned int jresult ;
61111   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61112   Dali::Dimension::Type arg2 ;
61113   SwigDirector_ViewImpl *darg = 0;
61114   bool result;
61115
61116   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61117   arg2 = (Dali::Dimension::Type)jarg2;
61118   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61119   {
61120     try {
61121       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
61122     } catch (std::out_of_range& e) {
61123       {
61124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61125       };
61126     } catch (std::exception& e) {
61127       {
61128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61129       };
61130     } catch (...) {
61131       {
61132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61133       };
61134     }
61135   }
61136   jresult = result;
61137   return jresult;
61138 }
61139
61140
61141 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
61142   unsigned int jresult ;
61143   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61144   Dali::Dimension::Type arg2 ;
61145   SwigDirector_ViewImpl *darg = 0;
61146   bool result;
61147
61148   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61149   arg2 = (Dali::Dimension::Type)jarg2;
61150   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61151   {
61152     try {
61153       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
61154     } catch (std::out_of_range& e) {
61155       {
61156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61157       };
61158     } catch (std::exception& e) {
61159       {
61160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61161       };
61162     } catch (...) {
61163       {
61164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61165       };
61166     }
61167   }
61168   jresult = result;
61169   return jresult;
61170 }
61171
61172
61173 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
61174   unsigned int jresult ;
61175   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61176   SwigDirector_ViewImpl *darg = 0;
61177   bool result;
61178
61179   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61180   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61181   {
61182     try {
61183       result = (bool)(darg)->RelayoutDependentOnChildren();
61184     } catch (std::out_of_range& e) {
61185       {
61186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61187       };
61188     } catch (std::exception& e) {
61189       {
61190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61191       };
61192     } catch (...) {
61193       {
61194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61195       };
61196     }
61197   }
61198   jresult = result;
61199   return jresult;
61200 }
61201
61202
61203 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
61204   unsigned int jresult ;
61205   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61206   SwigDirector_ViewImpl *darg = 0;
61207   bool result;
61208
61209   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61210   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61211   {
61212     try {
61213       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
61214     } catch (std::out_of_range& e) {
61215       {
61216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61217       };
61218     } catch (std::exception& e) {
61219       {
61220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61221       };
61222     } catch (...) {
61223       {
61224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61225       };
61226     }
61227   }
61228   jresult = result;
61229   return jresult;
61230 }
61231
61232
61233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
61234   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61235   Dali::Dimension::Type arg2 ;
61236   SwigDirector_ViewImpl *darg = 0;
61237
61238   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61239   arg2 = (Dali::Dimension::Type)jarg2;
61240   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61241   {
61242     try {
61243       (darg)->OnCalculateRelayoutSize(arg2);
61244     } catch (std::out_of_range& e) {
61245       {
61246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61247       };
61248     } catch (std::exception& e) {
61249       {
61250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61251       };
61252     } catch (...) {
61253       {
61254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61255       };
61256     }
61257   }
61258 }
61259
61260
61261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
61262   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61263   Dali::Dimension::Type arg2 ;
61264   SwigDirector_ViewImpl *darg = 0;
61265
61266   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61267   arg2 = (Dali::Dimension::Type)jarg2;
61268   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61269   {
61270     try {
61271       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
61272     } catch (std::out_of_range& e) {
61273       {
61274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61275       };
61276     } catch (std::exception& e) {
61277       {
61278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61279       };
61280     } catch (...) {
61281       {
61282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61283       };
61284     }
61285   }
61286 }
61287
61288
61289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
61290   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61291   float arg2 ;
61292   Dali::Dimension::Type arg3 ;
61293   SwigDirector_ViewImpl *darg = 0;
61294
61295   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61296   arg2 = (float)jarg2;
61297   arg3 = (Dali::Dimension::Type)jarg3;
61298   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61299   {
61300     try {
61301       (darg)->OnLayoutNegotiated(arg2,arg3);
61302     } catch (std::out_of_range& e) {
61303       {
61304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61305       };
61306     } catch (std::exception& e) {
61307       {
61308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61309       };
61310     } catch (...) {
61311       {
61312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61313       };
61314     }
61315   }
61316 }
61317
61318
61319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
61320   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61321   float arg2 ;
61322   Dali::Dimension::Type arg3 ;
61323   SwigDirector_ViewImpl *darg = 0;
61324
61325   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61326   arg2 = (float)jarg2;
61327   arg3 = (Dali::Dimension::Type)jarg3;
61328   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61329   {
61330     try {
61331       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
61332     } catch (std::out_of_range& e) {
61333       {
61334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61335       };
61336     } catch (std::exception& e) {
61337       {
61338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61339       };
61340     } catch (...) {
61341       {
61342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61343       };
61344     }
61345   }
61346 }
61347
61348
61349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
61350   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61351
61352   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61353   {
61354     try {
61355       (arg1)->OnInitialize();
61356     } catch (std::out_of_range& e) {
61357       {
61358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61359       };
61360     } catch (std::exception& e) {
61361       {
61362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61363       };
61364     } catch (...) {
61365       {
61366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61367       };
61368     }
61369   }
61370 }
61371
61372
61373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
61374   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61375
61376   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61377   {
61378     try {
61379       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
61380     } catch (std::out_of_range& e) {
61381       {
61382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61383       };
61384     } catch (std::exception& e) {
61385       {
61386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61387       };
61388     } catch (...) {
61389       {
61390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61391       };
61392     }
61393   }
61394 }
61395
61396
61397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
61398   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61399   Dali::Actor *arg2 = 0 ;
61400
61401   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61402   arg2 = (Dali::Actor *)jarg2;
61403   if (!arg2) {
61404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61405     return ;
61406   }
61407   {
61408     try {
61409       (arg1)->OnControlChildAdd(*arg2);
61410     } catch (std::out_of_range& e) {
61411       {
61412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61413       };
61414     } catch (std::exception& e) {
61415       {
61416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61417       };
61418     } catch (...) {
61419       {
61420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61421       };
61422     }
61423   }
61424 }
61425
61426
61427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61428   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61429   Dali::Actor *arg2 = 0 ;
61430
61431   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61432   arg2 = (Dali::Actor *)jarg2;
61433   if (!arg2) {
61434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61435     return ;
61436   }
61437   {
61438     try {
61439       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
61440     } catch (std::out_of_range& e) {
61441       {
61442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61443       };
61444     } catch (std::exception& e) {
61445       {
61446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61447       };
61448     } catch (...) {
61449       {
61450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61451       };
61452     }
61453   }
61454 }
61455
61456
61457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
61458   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61459   Dali::Actor *arg2 = 0 ;
61460
61461   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61462   arg2 = (Dali::Actor *)jarg2;
61463   if (!arg2) {
61464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61465     return ;
61466   }
61467   {
61468     try {
61469       (arg1)->OnControlChildRemove(*arg2);
61470     } catch (std::out_of_range& e) {
61471       {
61472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61473       };
61474     } catch (std::exception& e) {
61475       {
61476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61477       };
61478     } catch (...) {
61479       {
61480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61481       };
61482     }
61483   }
61484 }
61485
61486
61487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61488   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61489   Dali::Actor *arg2 = 0 ;
61490
61491   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61492   arg2 = (Dali::Actor *)jarg2;
61493   if (!arg2) {
61494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61495     return ;
61496   }
61497   {
61498     try {
61499       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
61500     } catch (std::out_of_range& e) {
61501       {
61502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61503       };
61504     } catch (std::exception& e) {
61505       {
61506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61507       };
61508     } catch (...) {
61509       {
61510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61511       };
61512     }
61513   }
61514 }
61515
61516
61517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
61518   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61519   Dali::Toolkit::StyleManager arg2 ;
61520   Dali::StyleChange::Type arg3 ;
61521   Dali::Toolkit::StyleManager *argp2 ;
61522
61523   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61524   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61525   if (!argp2) {
61526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61527     return ;
61528   }
61529   arg2 = *argp2;
61530   arg3 = (Dali::StyleChange::Type)jarg3;
61531   {
61532     try {
61533       (arg1)->OnStyleChange(arg2,arg3);
61534     } catch (std::out_of_range& e) {
61535       {
61536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61537       };
61538     } catch (std::exception& e) {
61539       {
61540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61541       };
61542     } catch (...) {
61543       {
61544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61545       };
61546     }
61547   }
61548 }
61549
61550
61551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61552   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61553   Dali::Toolkit::StyleManager arg2 ;
61554   Dali::StyleChange::Type arg3 ;
61555   Dali::Toolkit::StyleManager *argp2 ;
61556
61557   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61558   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61559   if (!argp2) {
61560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61561     return ;
61562   }
61563   arg2 = *argp2;
61564   arg3 = (Dali::StyleChange::Type)jarg3;
61565   {
61566     try {
61567       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
61568     } catch (std::out_of_range& e) {
61569       {
61570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61571       };
61572     } catch (std::exception& e) {
61573       {
61574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61575       };
61576     } catch (...) {
61577       {
61578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61579       };
61580     }
61581   }
61582 }
61583
61584
61585 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
61586   unsigned int jresult ;
61587   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61588   bool result;
61589
61590   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61591   {
61592     try {
61593       result = (bool)(arg1)->OnAccessibilityActivated();
61594     } catch (std::out_of_range& e) {
61595       {
61596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61597       };
61598     } catch (std::exception& e) {
61599       {
61600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61601       };
61602     } catch (...) {
61603       {
61604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61605       };
61606     }
61607   }
61608   jresult = result;
61609   return jresult;
61610 }
61611
61612
61613 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
61614   unsigned int jresult ;
61615   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61616   bool result;
61617
61618   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61619   {
61620     try {
61621       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
61622     } catch (std::out_of_range& e) {
61623       {
61624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61625       };
61626     } catch (std::exception& e) {
61627       {
61628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61629       };
61630     } catch (...) {
61631       {
61632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61633       };
61634     }
61635   }
61636   jresult = result;
61637   return jresult;
61638 }
61639
61640
61641 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
61642   unsigned int jresult ;
61643   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61644   Dali::PanGesture arg2 ;
61645   Dali::PanGesture *argp2 ;
61646   bool result;
61647
61648   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61649   argp2 = (Dali::PanGesture *)jarg2;
61650   if (!argp2) {
61651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
61652     return 0;
61653   }
61654   arg2 = *argp2;
61655   {
61656     try {
61657       result = (bool)(arg1)->OnAccessibilityPan(arg2);
61658     } catch (std::out_of_range& e) {
61659       {
61660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61661       };
61662     } catch (std::exception& e) {
61663       {
61664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61665       };
61666     } catch (...) {
61667       {
61668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61669       };
61670     }
61671   }
61672   jresult = result;
61673   return jresult;
61674 }
61675
61676
61677 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61678   unsigned int jresult ;
61679   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61680   Dali::PanGesture arg2 ;
61681   Dali::PanGesture *argp2 ;
61682   bool result;
61683
61684   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61685   argp2 = (Dali::PanGesture *)jarg2;
61686   if (!argp2) {
61687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
61688     return 0;
61689   }
61690   arg2 = *argp2;
61691   {
61692     try {
61693       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
61694     } catch (std::out_of_range& e) {
61695       {
61696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61697       };
61698     } catch (std::exception& e) {
61699       {
61700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61701       };
61702     } catch (...) {
61703       {
61704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61705       };
61706     }
61707   }
61708   jresult = result;
61709   return jresult;
61710 }
61711
61712
61713 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
61714   unsigned int jresult ;
61715   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61716   Dali::TouchEvent *arg2 = 0 ;
61717   bool result;
61718
61719   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61720   arg2 = (Dali::TouchEvent *)jarg2;
61721   if (!arg2) {
61722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61723     return 0;
61724   }
61725   {
61726     try {
61727       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
61728     } catch (std::out_of_range& e) {
61729       {
61730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61731       };
61732     } catch (std::exception& e) {
61733       {
61734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61735       };
61736     } catch (...) {
61737       {
61738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61739       };
61740     }
61741   }
61742   jresult = result;
61743   return jresult;
61744 }
61745
61746
61747 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61748   unsigned int jresult ;
61749   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61750   Dali::TouchEvent *arg2 = 0 ;
61751   bool result;
61752
61753   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61754   arg2 = (Dali::TouchEvent *)jarg2;
61755   if (!arg2) {
61756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61757     return 0;
61758   }
61759   {
61760     try {
61761       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
61762     } catch (std::out_of_range& e) {
61763       {
61764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61765       };
61766     } catch (std::exception& e) {
61767       {
61768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61769       };
61770     } catch (...) {
61771       {
61772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61773       };
61774     }
61775   }
61776   jresult = result;
61777   return jresult;
61778 }
61779
61780
61781 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
61782   unsigned int jresult ;
61783   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61784   bool arg2 ;
61785   bool result;
61786
61787   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61788   arg2 = jarg2 ? true : false;
61789   {
61790     try {
61791       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
61792     } catch (std::out_of_range& e) {
61793       {
61794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61795       };
61796     } catch (std::exception& e) {
61797       {
61798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61799       };
61800     } catch (...) {
61801       {
61802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61803       };
61804     }
61805   }
61806   jresult = result;
61807   return jresult;
61808 }
61809
61810
61811 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
61812   unsigned int jresult ;
61813   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61814   bool arg2 ;
61815   bool result;
61816
61817   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61818   arg2 = jarg2 ? true : false;
61819   {
61820     try {
61821       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
61822     } catch (std::out_of_range& e) {
61823       {
61824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61825       };
61826     } catch (std::exception& e) {
61827       {
61828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61829       };
61830     } catch (...) {
61831       {
61832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61833       };
61834     }
61835   }
61836   jresult = result;
61837   return jresult;
61838 }
61839
61840
61841 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
61842   unsigned int jresult ;
61843   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61844   bool result;
61845
61846   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61847   {
61848     try {
61849       result = (bool)(arg1)->OnAccessibilityZoom();
61850     } catch (std::out_of_range& e) {
61851       {
61852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61853       };
61854     } catch (std::exception& e) {
61855       {
61856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61857       };
61858     } catch (...) {
61859       {
61860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61861       };
61862     }
61863   }
61864   jresult = result;
61865   return jresult;
61866 }
61867
61868
61869 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
61870   unsigned int jresult ;
61871   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61872   bool result;
61873
61874   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61875   {
61876     try {
61877       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
61878     } catch (std::out_of_range& e) {
61879       {
61880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61881       };
61882     } catch (std::exception& e) {
61883       {
61884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61885       };
61886     } catch (...) {
61887       {
61888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61889       };
61890     }
61891   }
61892   jresult = result;
61893   return jresult;
61894 }
61895
61896
61897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
61898   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61899
61900   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61901   {
61902     try {
61903       (arg1)->OnKeyInputFocusGained();
61904     } catch (std::out_of_range& e) {
61905       {
61906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61907       };
61908     } catch (std::exception& e) {
61909       {
61910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61911       };
61912     } catch (...) {
61913       {
61914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61915       };
61916     }
61917   }
61918 }
61919
61920
61921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
61922   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61923
61924   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61925   {
61926     try {
61927       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
61928     } catch (std::out_of_range& e) {
61929       {
61930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61931       };
61932     } catch (std::exception& e) {
61933       {
61934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61935       };
61936     } catch (...) {
61937       {
61938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61939       };
61940     }
61941   }
61942 }
61943
61944
61945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
61946   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61947
61948   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61949   {
61950     try {
61951       (arg1)->OnKeyInputFocusLost();
61952     } catch (std::out_of_range& e) {
61953       {
61954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61955       };
61956     } catch (std::exception& e) {
61957       {
61958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61959       };
61960     } catch (...) {
61961       {
61962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61963       };
61964     }
61965   }
61966 }
61967
61968
61969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
61970   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61971
61972   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61973   {
61974     try {
61975       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
61976     } catch (std::out_of_range& e) {
61977       {
61978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61979       };
61980     } catch (std::exception& e) {
61981       {
61982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61983       };
61984     } catch (...) {
61985       {
61986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61987       };
61988     }
61989   }
61990 }
61991
61992
61993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
61994   void * jresult ;
61995   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61996   Dali::Actor arg2 ;
61997   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
61998   bool arg4 ;
61999   Dali::Actor *argp2 ;
62000   Dali::Actor result;
62001
62002   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62003   argp2 = (Dali::Actor *)jarg2;
62004   if (!argp2) {
62005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62006     return 0;
62007   }
62008   arg2 = *argp2;
62009   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62010   arg4 = jarg4 ? true : false;
62011   {
62012     try {
62013       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62014     } catch (std::out_of_range& e) {
62015       {
62016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62017       };
62018     } catch (std::exception& e) {
62019       {
62020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62021       };
62022     } catch (...) {
62023       {
62024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62025       };
62026     }
62027   }
62028   jresult = new Dali::Actor((const Dali::Actor &)result);
62029   return jresult;
62030 }
62031
62032
62033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62034   void * jresult ;
62035   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62036   Dali::Actor arg2 ;
62037   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62038   bool arg4 ;
62039   Dali::Actor *argp2 ;
62040   Dali::Actor result;
62041
62042   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62043   argp2 = (Dali::Actor *)jarg2;
62044   if (!argp2) {
62045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62046     return 0;
62047   }
62048   arg2 = *argp2;
62049   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62050   arg4 = jarg4 ? true : false;
62051   {
62052     try {
62053       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62054     } catch (std::out_of_range& e) {
62055       {
62056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62057       };
62058     } catch (std::exception& e) {
62059       {
62060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62061       };
62062     } catch (...) {
62063       {
62064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62065       };
62066     }
62067   }
62068   jresult = new Dali::Actor((const Dali::Actor &)result);
62069   return jresult;
62070 }
62071
62072
62073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
62074   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62075   Dali::Actor arg2 ;
62076   Dali::Actor *argp2 ;
62077
62078   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62079   argp2 = (Dali::Actor *)jarg2;
62080   if (!argp2) {
62081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62082     return ;
62083   }
62084   arg2 = *argp2;
62085   {
62086     try {
62087       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
62088     } catch (std::out_of_range& e) {
62089       {
62090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62091       };
62092     } catch (std::exception& e) {
62093       {
62094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62095       };
62096     } catch (...) {
62097       {
62098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62099       };
62100     }
62101   }
62102 }
62103
62104
62105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62106   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62107   Dali::Actor arg2 ;
62108   Dali::Actor *argp2 ;
62109
62110   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62111   argp2 = (Dali::Actor *)jarg2;
62112   if (!argp2) {
62113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62114     return ;
62115   }
62116   arg2 = *argp2;
62117   {
62118     try {
62119       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
62120     } catch (std::out_of_range& e) {
62121       {
62122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62123       };
62124     } catch (std::exception& e) {
62125       {
62126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62127       };
62128     } catch (...) {
62129       {
62130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62131       };
62132     }
62133   }
62134 }
62135
62136
62137 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
62138   unsigned int jresult ;
62139   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62140   bool result;
62141
62142   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62143   {
62144     try {
62145       result = (bool)(arg1)->OnKeyboardEnter();
62146     } catch (std::out_of_range& e) {
62147       {
62148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62149       };
62150     } catch (std::exception& e) {
62151       {
62152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62153       };
62154     } catch (...) {
62155       {
62156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62157       };
62158     }
62159   }
62160   jresult = result;
62161   return jresult;
62162 }
62163
62164
62165 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
62166   unsigned int jresult ;
62167   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62168   bool result;
62169
62170   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62171   {
62172     try {
62173       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
62174     } catch (std::out_of_range& e) {
62175       {
62176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62177       };
62178     } catch (std::exception& e) {
62179       {
62180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62181       };
62182     } catch (...) {
62183       {
62184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62185       };
62186     }
62187   }
62188   jresult = result;
62189   return jresult;
62190 }
62191
62192
62193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
62194   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62195   Dali::PinchGesture *arg2 = 0 ;
62196
62197   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62198   arg2 = (Dali::PinchGesture *)jarg2;
62199   if (!arg2) {
62200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62201     return ;
62202   }
62203   {
62204     try {
62205       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
62206     } catch (std::out_of_range& e) {
62207       {
62208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62209       };
62210     } catch (std::exception& e) {
62211       {
62212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62213       };
62214     } catch (...) {
62215       {
62216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62217       };
62218     }
62219   }
62220 }
62221
62222
62223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62224   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62225   Dali::PinchGesture *arg2 = 0 ;
62226
62227   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62228   arg2 = (Dali::PinchGesture *)jarg2;
62229   if (!arg2) {
62230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62231     return ;
62232   }
62233   {
62234     try {
62235       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
62236     } catch (std::out_of_range& e) {
62237       {
62238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62239       };
62240     } catch (std::exception& e) {
62241       {
62242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62243       };
62244     } catch (...) {
62245       {
62246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62247       };
62248     }
62249   }
62250 }
62251
62252
62253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
62254   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62255   Dali::PanGesture *arg2 = 0 ;
62256
62257   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62258   arg2 = (Dali::PanGesture *)jarg2;
62259   if (!arg2) {
62260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62261     return ;
62262   }
62263   {
62264     try {
62265       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
62266     } catch (std::out_of_range& e) {
62267       {
62268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62269       };
62270     } catch (std::exception& e) {
62271       {
62272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62273       };
62274     } catch (...) {
62275       {
62276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62277       };
62278     }
62279   }
62280 }
62281
62282
62283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62284   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62285   Dali::PanGesture *arg2 = 0 ;
62286
62287   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62288   arg2 = (Dali::PanGesture *)jarg2;
62289   if (!arg2) {
62290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62291     return ;
62292   }
62293   {
62294     try {
62295       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
62296     } catch (std::out_of_range& e) {
62297       {
62298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62299       };
62300     } catch (std::exception& e) {
62301       {
62302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62303       };
62304     } catch (...) {
62305       {
62306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62307       };
62308     }
62309   }
62310 }
62311
62312
62313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
62314   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62315   Dali::TapGesture *arg2 = 0 ;
62316
62317   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62318   arg2 = (Dali::TapGesture *)jarg2;
62319   if (!arg2) {
62320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
62321     return ;
62322   }
62323   {
62324     try {
62325       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
62326     } catch (std::out_of_range& e) {
62327       {
62328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62329       };
62330     } catch (std::exception& e) {
62331       {
62332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62333       };
62334     } catch (...) {
62335       {
62336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62337       };
62338     }
62339   }
62340 }
62341
62342
62343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62344   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62345   Dali::TapGesture *arg2 = 0 ;
62346
62347   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62348   arg2 = (Dali::TapGesture *)jarg2;
62349   if (!arg2) {
62350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
62351     return ;
62352   }
62353   {
62354     try {
62355       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
62356     } catch (std::out_of_range& e) {
62357       {
62358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62359       };
62360     } catch (std::exception& e) {
62361       {
62362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62363       };
62364     } catch (...) {
62365       {
62366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62367       };
62368     }
62369   }
62370 }
62371
62372
62373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
62374   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62375   Dali::LongPressGesture *arg2 = 0 ;
62376
62377   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62378   arg2 = (Dali::LongPressGesture *)jarg2;
62379   if (!arg2) {
62380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62381     return ;
62382   }
62383   {
62384     try {
62385       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
62386     } catch (std::out_of_range& e) {
62387       {
62388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62389       };
62390     } catch (std::exception& e) {
62391       {
62392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62393       };
62394     } catch (...) {
62395       {
62396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62397       };
62398     }
62399   }
62400 }
62401
62402
62403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62404   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62405   Dali::LongPressGesture *arg2 = 0 ;
62406
62407   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62408   arg2 = (Dali::LongPressGesture *)jarg2;
62409   if (!arg2) {
62410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62411     return ;
62412   }
62413   {
62414     try {
62415       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
62416     } catch (std::out_of_range& e) {
62417       {
62418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62419       };
62420     } catch (std::exception& e) {
62421       {
62422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62423       };
62424     } catch (...) {
62425       {
62426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62427       };
62428     }
62429   }
62430 }
62431
62432
62433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
62434   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62435   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62436   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62437
62438   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62439   arg2 = (Dali::SlotObserver *)jarg2;
62440   arg3 = (Dali::CallbackBase *)jarg3;
62441   {
62442     try {
62443       (arg1)->SignalConnected(arg2,arg3);
62444     } catch (std::out_of_range& e) {
62445       {
62446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62447       };
62448     } catch (std::exception& e) {
62449       {
62450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62451       };
62452     } catch (...) {
62453       {
62454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62455       };
62456     }
62457   }
62458 }
62459
62460
62461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62462   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62463   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62464   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62465
62466   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62467   arg2 = (Dali::SlotObserver *)jarg2;
62468   arg3 = (Dali::CallbackBase *)jarg3;
62469   {
62470     try {
62471       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
62472     } catch (std::out_of_range& e) {
62473       {
62474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62475       };
62476     } catch (std::exception& e) {
62477       {
62478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62479       };
62480     } catch (...) {
62481       {
62482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62483       };
62484     }
62485   }
62486 }
62487
62488
62489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
62490   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62491   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62492   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62493
62494   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62495   arg2 = (Dali::SlotObserver *)jarg2;
62496   arg3 = (Dali::CallbackBase *)jarg3;
62497   {
62498     try {
62499       (arg1)->SignalDisconnected(arg2,arg3);
62500     } catch (std::out_of_range& e) {
62501       {
62502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62503       };
62504     } catch (std::exception& e) {
62505       {
62506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62507       };
62508     } catch (...) {
62509       {
62510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62511       };
62512     }
62513   }
62514 }
62515
62516
62517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62518   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62519   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62520   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62521
62522   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62523   arg2 = (Dali::SlotObserver *)jarg2;
62524   arg3 = (Dali::CallbackBase *)jarg3;
62525   {
62526     try {
62527       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
62528     } catch (std::out_of_range& e) {
62529       {
62530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62531       };
62532     } catch (std::exception& e) {
62533       {
62534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62535       };
62536     } catch (...) {
62537       {
62538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62539       };
62540     }
62541   }
62542 }
62543
62544
62545 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) {
62546   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
62547   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
62548   if (director) {
62549     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);
62550   }
62551 }
62552
62553
62554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
62555   void * jresult ;
62556   Dali::Toolkit::Control *arg1 = 0 ;
62557   Dali::Toolkit::Internal::Control *result = 0 ;
62558
62559   arg1 = (Dali::Toolkit::Control *)jarg1;
62560   if (!arg1) {
62561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
62562     return 0;
62563   }
62564   {
62565     try {
62566       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
62567     } catch (std::out_of_range& e) {
62568       {
62569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62570       };
62571     } catch (std::exception& e) {
62572       {
62573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62574       };
62575     } catch (...) {
62576       {
62577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62578       };
62579     }
62580   }
62581   jresult = (void *)result;
62582   return jresult;
62583 }
62584
62585
62586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
62587   int jresult ;
62588   int result;
62589
62590   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
62591   jresult = (int)result;
62592   return jresult;
62593 }
62594
62595
62596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
62597   int jresult ;
62598   int result;
62599
62600   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
62601   jresult = (int)result;
62602   return jresult;
62603 }
62604
62605
62606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
62607   int jresult ;
62608   int result;
62609
62610   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
62611   jresult = (int)result;
62612   return jresult;
62613 }
62614
62615
62616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
62617   int jresult ;
62618   int result;
62619
62620   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
62621   jresult = (int)result;
62622   return jresult;
62623 }
62624
62625
62626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
62627   int jresult ;
62628   int result;
62629
62630   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
62631   jresult = (int)result;
62632   return jresult;
62633 }
62634
62635
62636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
62637   void * jresult ;
62638   Dali::Toolkit::Control::Property *result = 0 ;
62639
62640   {
62641     try {
62642       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
62643     } catch (std::out_of_range& e) {
62644       {
62645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62646       };
62647     } catch (std::exception& e) {
62648       {
62649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62650       };
62651     } catch (...) {
62652       {
62653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62654       };
62655     }
62656   }
62657   jresult = (void *)result;
62658   return jresult;
62659 }
62660
62661
62662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
62663   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
62664
62665   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
62666   {
62667     try {
62668       delete arg1;
62669     } catch (std::out_of_range& e) {
62670       {
62671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62672       };
62673     } catch (std::exception& e) {
62674       {
62675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62676       };
62677     } catch (...) {
62678       {
62679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62680       };
62681     }
62682   }
62683 }
62684
62685
62686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
62687   void * jresult ;
62688   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
62689
62690   {
62691     try {
62692       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
62693     } catch (std::out_of_range& e) {
62694       {
62695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62696       };
62697     } catch (std::exception& e) {
62698       {
62699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62700       };
62701     } catch (...) {
62702       {
62703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62704       };
62705     }
62706   }
62707   jresult = (void *)result;
62708   return jresult;
62709 }
62710
62711
62712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
62713   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
62714
62715   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
62716   {
62717     try {
62718       delete arg1;
62719     } catch (std::out_of_range& e) {
62720       {
62721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62722       };
62723     } catch (std::exception& e) {
62724       {
62725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62726       };
62727     } catch (...) {
62728       {
62729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62730       };
62731     }
62732   }
62733 }
62734
62735
62736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
62737   void * jresult ;
62738   Dali::Toolkit::Control result;
62739
62740   {
62741     try {
62742       result = Dali::Toolkit::Control::New();
62743     } catch (std::out_of_range& e) {
62744       {
62745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62746       };
62747     } catch (std::exception& e) {
62748       {
62749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62750       };
62751     } catch (...) {
62752       {
62753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62754       };
62755     }
62756   }
62757   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
62758   return jresult;
62759 }
62760
62761
62762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
62763   void * jresult ;
62764   Dali::Toolkit::Control *result = 0 ;
62765
62766   {
62767     try {
62768       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
62769     } catch (std::out_of_range& e) {
62770       {
62771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62772       };
62773     } catch (std::exception& e) {
62774       {
62775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62776       };
62777     } catch (...) {
62778       {
62779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62780       };
62781     }
62782   }
62783   jresult = (void *)result;
62784   return jresult;
62785 }
62786
62787
62788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
62789   void * jresult ;
62790   Dali::Toolkit::Control *arg1 = 0 ;
62791   Dali::Toolkit::Control *result = 0 ;
62792
62793   arg1 = (Dali::Toolkit::Control *)jarg1;
62794   if (!arg1) {
62795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
62796     return 0;
62797   }
62798   {
62799     try {
62800       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
62801     } catch (std::out_of_range& e) {
62802       {
62803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62804       };
62805     } catch (std::exception& e) {
62806       {
62807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62808       };
62809     } catch (...) {
62810       {
62811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62812       };
62813     }
62814   }
62815   jresult = (void *)result;
62816   return jresult;
62817 }
62818
62819
62820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
62821   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62822
62823   arg1 = (Dali::Toolkit::Control *)jarg1;
62824   {
62825     try {
62826       delete arg1;
62827     } catch (std::out_of_range& e) {
62828       {
62829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62830       };
62831     } catch (std::exception& e) {
62832       {
62833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62834       };
62835     } catch (...) {
62836       {
62837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62838       };
62839     }
62840   }
62841 }
62842
62843
62844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
62845   void * jresult ;
62846   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62847   Dali::Toolkit::Control *arg2 = 0 ;
62848   Dali::Toolkit::Control *result = 0 ;
62849
62850   arg1 = (Dali::Toolkit::Control *)jarg1;
62851   arg2 = (Dali::Toolkit::Control *)jarg2;
62852   if (!arg2) {
62853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
62854     return 0;
62855   }
62856   {
62857     try {
62858       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
62859     } catch (std::out_of_range& e) {
62860       {
62861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62862       };
62863     } catch (std::exception& e) {
62864       {
62865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62866       };
62867     } catch (...) {
62868       {
62869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62870       };
62871     }
62872   }
62873   jresult = (void *)result;
62874   return jresult;
62875 }
62876
62877
62878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
62879   void * jresult ;
62880   Dali::BaseHandle arg1 ;
62881   Dali::BaseHandle *argp1 ;
62882   Dali::Toolkit::Control result;
62883
62884   argp1 = (Dali::BaseHandle *)jarg1;
62885   if (!argp1) {
62886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62887     return 0;
62888   }
62889   arg1 = *argp1;
62890   {
62891     try {
62892       result = Dali::Toolkit::Control::DownCast(arg1);
62893     } catch (std::out_of_range& e) {
62894       {
62895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62896       };
62897     } catch (std::exception& e) {
62898       {
62899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62900       };
62901     } catch (...) {
62902       {
62903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62904       };
62905     }
62906   }
62907   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
62908   return jresult;
62909 }
62910
62911
62912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
62913   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62914
62915   arg1 = (Dali::Toolkit::Control *)jarg1;
62916   {
62917     try {
62918       (arg1)->SetKeyInputFocus();
62919     } catch (std::out_of_range& e) {
62920       {
62921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62922       };
62923     } catch (std::exception& e) {
62924       {
62925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62926       };
62927     } catch (...) {
62928       {
62929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62930       };
62931     }
62932   }
62933 }
62934
62935
62936 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
62937   unsigned int jresult ;
62938   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62939   bool result;
62940
62941   arg1 = (Dali::Toolkit::Control *)jarg1;
62942   {
62943     try {
62944       result = (bool)(arg1)->HasKeyInputFocus();
62945     } catch (std::out_of_range& e) {
62946       {
62947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62948       };
62949     } catch (std::exception& e) {
62950       {
62951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62952       };
62953     } catch (...) {
62954       {
62955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62956       };
62957     }
62958   }
62959   jresult = result;
62960   return jresult;
62961 }
62962
62963
62964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
62965   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62966
62967   arg1 = (Dali::Toolkit::Control *)jarg1;
62968   {
62969     try {
62970       (arg1)->ClearKeyInputFocus();
62971     } catch (std::out_of_range& e) {
62972       {
62973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62974       };
62975     } catch (std::exception& e) {
62976       {
62977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62978       };
62979     } catch (...) {
62980       {
62981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62982       };
62983     }
62984   }
62985 }
62986
62987
62988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
62989   void * jresult ;
62990   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62991   Dali::PinchGestureDetector result;
62992
62993   arg1 = (Dali::Toolkit::Control *)jarg1;
62994   {
62995     try {
62996       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
62997     } catch (std::out_of_range& e) {
62998       {
62999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63000       };
63001     } catch (std::exception& e) {
63002       {
63003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63004       };
63005     } catch (...) {
63006       {
63007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63008       };
63009     }
63010   }
63011   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63012   return jresult;
63013 }
63014
63015
63016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
63017   void * jresult ;
63018   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63019   Dali::PanGestureDetector result;
63020
63021   arg1 = (Dali::Toolkit::Control *)jarg1;
63022   {
63023     try {
63024       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
63025     } catch (std::out_of_range& e) {
63026       {
63027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63028       };
63029     } catch (std::exception& e) {
63030       {
63031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63032       };
63033     } catch (...) {
63034       {
63035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63036       };
63037     }
63038   }
63039   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63040   return jresult;
63041 }
63042
63043
63044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
63045   void * jresult ;
63046   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63047   Dali::TapGestureDetector result;
63048
63049   arg1 = (Dali::Toolkit::Control *)jarg1;
63050   {
63051     try {
63052       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
63053     } catch (std::out_of_range& e) {
63054       {
63055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63056       };
63057     } catch (std::exception& e) {
63058       {
63059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63060       };
63061     } catch (...) {
63062       {
63063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63064       };
63065     }
63066   }
63067   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63068   return jresult;
63069 }
63070
63071
63072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
63073   void * jresult ;
63074   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63075   Dali::LongPressGestureDetector result;
63076
63077   arg1 = (Dali::Toolkit::Control *)jarg1;
63078   {
63079     try {
63080       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
63081     } catch (std::out_of_range& e) {
63082       {
63083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63084       };
63085     } catch (std::exception& e) {
63086       {
63087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63088       };
63089     } catch (...) {
63090       {
63091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63092       };
63093     }
63094   }
63095   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63096   return jresult;
63097 }
63098
63099
63100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
63101   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63102   std::string *arg2 = 0 ;
63103
63104   arg1 = (Dali::Toolkit::Control *)jarg1;
63105   if (!jarg2) {
63106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63107     return ;
63108   }
63109   std::string arg2_str(jarg2);
63110   arg2 = &arg2_str;
63111   {
63112     try {
63113       (arg1)->SetStyleName((std::string const &)*arg2);
63114     } catch (std::out_of_range& e) {
63115       {
63116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63117       };
63118     } catch (std::exception& e) {
63119       {
63120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63121       };
63122     } catch (...) {
63123       {
63124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63125       };
63126     }
63127   }
63128
63129   //argout typemap for const std::string&
63130
63131 }
63132
63133
63134 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
63135   char * jresult ;
63136   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63137   std::string *result = 0 ;
63138
63139   arg1 = (Dali::Toolkit::Control *)jarg1;
63140   {
63141     try {
63142       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
63143     } catch (std::out_of_range& e) {
63144       {
63145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63146       };
63147     } catch (std::exception& e) {
63148       {
63149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63150       };
63151     } catch (...) {
63152       {
63153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63154       };
63155     }
63156   }
63157   jresult = SWIG_csharp_string_callback(result->c_str());
63158   return jresult;
63159 }
63160
63161
63162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
63163   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63164   Dali::Vector4 *arg2 = 0 ;
63165
63166   arg1 = (Dali::Toolkit::Control *)jarg1;
63167   arg2 = (Dali::Vector4 *)jarg2;
63168   if (!arg2) {
63169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63170     return ;
63171   }
63172   {
63173     try {
63174       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63175     } catch (std::out_of_range& e) {
63176       {
63177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63178       };
63179     } catch (std::exception& e) {
63180       {
63181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63182       };
63183     } catch (...) {
63184       {
63185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63186       };
63187     }
63188   }
63189 }
63190
63191
63192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
63193   void * jresult ;
63194   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63195   Dali::Vector4 result;
63196
63197   arg1 = (Dali::Toolkit::Control *)jarg1;
63198   {
63199     try {
63200       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
63201     } catch (std::out_of_range& e) {
63202       {
63203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63204       };
63205     } catch (std::exception& e) {
63206       {
63207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63208       };
63209     } catch (...) {
63210       {
63211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63212       };
63213     }
63214   }
63215   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63216   return jresult;
63217 }
63218
63219
63220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
63221   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63222   Dali::Image arg2 ;
63223   Dali::Image *argp2 ;
63224
63225   arg1 = (Dali::Toolkit::Control *)jarg1;
63226   argp2 = (Dali::Image *)jarg2;
63227   if (!argp2) {
63228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63229     return ;
63230   }
63231   arg2 = *argp2;
63232   {
63233     try {
63234       (arg1)->SetBackgroundImage(arg2);
63235     } catch (std::out_of_range& e) {
63236       {
63237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63238       };
63239     } catch (std::exception& e) {
63240       {
63241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63242       };
63243     } catch (...) {
63244       {
63245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63246       };
63247     }
63248   }
63249 }
63250
63251
63252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
63253   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63254
63255   arg1 = (Dali::Toolkit::Control *)jarg1;
63256   {
63257     try {
63258       (arg1)->ClearBackground();
63259     } catch (std::out_of_range& e) {
63260       {
63261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63262       };
63263     } catch (std::exception& e) {
63264       {
63265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63266       };
63267     } catch (...) {
63268       {
63269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63270       };
63271     }
63272   }
63273 }
63274
63275
63276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
63277   void * jresult ;
63278   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63279   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63280
63281   arg1 = (Dali::Toolkit::Control *)jarg1;
63282   {
63283     try {
63284       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63285     } catch (std::out_of_range& e) {
63286       {
63287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63288       };
63289     } catch (std::exception& e) {
63290       {
63291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63292       };
63293     } catch (...) {
63294       {
63295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63296       };
63297     }
63298   }
63299   jresult = (void *)result;
63300   return jresult;
63301 }
63302
63303
63304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
63305   void * jresult ;
63306   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63307   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63308
63309   arg1 = (Dali::Toolkit::Control *)jarg1;
63310   {
63311     try {
63312       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
63313     } catch (std::out_of_range& e) {
63314       {
63315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63316       };
63317     } catch (std::exception& e) {
63318       {
63319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63320       };
63321     } catch (...) {
63322       {
63323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63324       };
63325     }
63326   }
63327   jresult = (void *)result;
63328   return jresult;
63329 }
63330
63331
63332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
63333   void * jresult ;
63334   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63335   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63336
63337   arg1 = (Dali::Toolkit::Control *)jarg1;
63338   {
63339     try {
63340       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
63341     } catch (std::out_of_range& e) {
63342       {
63343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63344       };
63345     } catch (std::exception& e) {
63346       {
63347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63348       };
63349     } catch (...) {
63350       {
63351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63352       };
63353     }
63354   }
63355   jresult = (void *)result;
63356   return jresult;
63357 }
63358
63359
63360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
63361   void * jresult ;
63362   Dali::Toolkit::Internal::Control *arg1 = 0 ;
63363   Dali::Toolkit::Control *result = 0 ;
63364
63365   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63366   if (!arg1) {
63367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
63368     return 0;
63369   }
63370   {
63371     try {
63372       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
63373     } catch (std::out_of_range& e) {
63374       {
63375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63376       };
63377     } catch (std::exception& e) {
63378       {
63379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63380       };
63381     } catch (...) {
63382       {
63383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63384       };
63385     }
63386   }
63387   jresult = (void *)result;
63388   return jresult;
63389 }
63390
63391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
63392   void * jresult ;
63393   Dali::Toolkit::Control *arg1 = 0 ;
63394   Dali::Toolkit::DevelControl::ResourceReadySignalType *result = 0 ;
63395
63396   arg1 = (Dali::Toolkit::Control *)jarg1;
63397   if (!arg1) {
63398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63399     return 0;
63400   }
63401   {
63402     try {
63403       result = (Dali::Toolkit::DevelControl::ResourceReadySignalType *) &Dali::Toolkit::DevelControl::ResourceReadySignal(*arg1);
63404     } catch (std::out_of_range& e) {
63405       {
63406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63407       };
63408     } catch (std::exception& e) {
63409       {
63410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63411       };
63412     } catch (...) {
63413       {
63414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63415       };
63416     }
63417   }
63418   jresult = (void *)result;
63419   return jresult;
63420 }
63421
63422
63423 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
63424   unsigned int jresult ;
63425   Dali::Toolkit::Control *arg1 = 0 ;
63426   bool result;
63427
63428   arg1 = (Dali::Toolkit::Control *)jarg1;
63429   if (!arg1) {
63430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63431     return 0;
63432   }
63433   {
63434     try {
63435       result = (bool)Dali::Toolkit::DevelControl::IsResourceReady((Dali::Toolkit::Control const &)*arg1);
63436     } catch (std::out_of_range& e) {
63437       {
63438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63439       };
63440     } catch (std::exception& e) {
63441       {
63442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63443       };
63444     } catch (...) {
63445       {
63446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63447       };
63448     }
63449   }
63450   jresult = result;
63451   return jresult;
63452 }
63453
63454
63455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
63456   void * jresult ;
63457   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
63458
63459   {
63460     try {
63461       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
63462     } catch (std::out_of_range& e) {
63463       {
63464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63465       };
63466     } catch (std::exception& e) {
63467       {
63468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63469       };
63470     } catch (...) {
63471       {
63472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63473       };
63474     }
63475   }
63476   jresult = (void *)result;
63477   return jresult;
63478 }
63479
63480
63481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
63482   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63483
63484   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63485   {
63486     try {
63487       delete arg1;
63488     } catch (std::out_of_range& e) {
63489       {
63490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63491       };
63492     } catch (std::exception& e) {
63493       {
63494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63495       };
63496     } catch (...) {
63497       {
63498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63499       };
63500     }
63501   }
63502 }
63503
63504
63505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
63506   void * jresult ;
63507   Dali::Toolkit::KeyInputFocusManager result;
63508
63509   {
63510     try {
63511       result = Dali::Toolkit::KeyInputFocusManager::Get();
63512     } catch (std::out_of_range& e) {
63513       {
63514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63515       };
63516     } catch (std::exception& e) {
63517       {
63518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63519       };
63520     } catch (...) {
63521       {
63522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63523       };
63524     }
63525   }
63526   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
63527   return jresult;
63528 }
63529
63530
63531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
63532   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63533   Dali::Toolkit::Control arg2 ;
63534   Dali::Toolkit::Control *argp2 ;
63535
63536   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63537   argp2 = (Dali::Toolkit::Control *)jarg2;
63538   if (!argp2) {
63539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
63540     return ;
63541   }
63542   arg2 = *argp2;
63543   {
63544     try {
63545       (arg1)->SetFocus(arg2);
63546     } catch (std::out_of_range& e) {
63547       {
63548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63549       };
63550     } catch (std::exception& e) {
63551       {
63552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63553       };
63554     } catch (...) {
63555       {
63556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63557       };
63558     }
63559   }
63560 }
63561
63562
63563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
63564   void * jresult ;
63565   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63566   Dali::Toolkit::Control result;
63567
63568   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63569   {
63570     try {
63571       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
63572     } catch (std::out_of_range& e) {
63573       {
63574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63575       };
63576     } catch (std::exception& e) {
63577       {
63578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63579       };
63580     } catch (...) {
63581       {
63582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63583       };
63584     }
63585   }
63586   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63587   return jresult;
63588 }
63589
63590
63591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
63592   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63593   Dali::Toolkit::Control arg2 ;
63594   Dali::Toolkit::Control *argp2 ;
63595
63596   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63597   argp2 = (Dali::Toolkit::Control *)jarg2;
63598   if (!argp2) {
63599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
63600     return ;
63601   }
63602   arg2 = *argp2;
63603   {
63604     try {
63605       (arg1)->RemoveFocus(arg2);
63606     } catch (std::out_of_range& e) {
63607       {
63608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63609       };
63610     } catch (std::exception& e) {
63611       {
63612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63613       };
63614     } catch (...) {
63615       {
63616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63617       };
63618     }
63619   }
63620 }
63621
63622
63623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
63624   void * jresult ;
63625   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63626   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
63627
63628   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63629   {
63630     try {
63631       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
63632     } catch (std::out_of_range& e) {
63633       {
63634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63635       };
63636     } catch (std::exception& e) {
63637       {
63638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63639       };
63640     } catch (...) {
63641       {
63642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63643       };
63644     }
63645   }
63646   jresult = (void *)result;
63647   return jresult;
63648 }
63649
63650
63651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
63652   void * jresult ;
63653   Dali::Toolkit::Alignment::Padding *result = 0 ;
63654
63655   {
63656     try {
63657       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
63658     } catch (std::out_of_range& e) {
63659       {
63660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63661       };
63662     } catch (std::exception& e) {
63663       {
63664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63665       };
63666     } catch (...) {
63667       {
63668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63669       };
63670     }
63671   }
63672   jresult = (void *)result;
63673   return jresult;
63674 }
63675
63676
63677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
63678   void * jresult ;
63679   float arg1 ;
63680   float arg2 ;
63681   float arg3 ;
63682   float arg4 ;
63683   Dali::Toolkit::Alignment::Padding *result = 0 ;
63684
63685   arg1 = (float)jarg1;
63686   arg2 = (float)jarg2;
63687   arg3 = (float)jarg3;
63688   arg4 = (float)jarg4;
63689   {
63690     try {
63691       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
63692     } catch (std::out_of_range& e) {
63693       {
63694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63695       };
63696     } catch (std::exception& e) {
63697       {
63698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63699       };
63700     } catch (...) {
63701       {
63702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63703       };
63704     }
63705   }
63706   jresult = (void *)result;
63707   return jresult;
63708 }
63709
63710
63711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
63712   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63713   float arg2 ;
63714
63715   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63716   arg2 = (float)jarg2;
63717   if (arg1) (arg1)->left = arg2;
63718 }
63719
63720
63721 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
63722   float jresult ;
63723   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63724   float result;
63725
63726   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63727   result = (float) ((arg1)->left);
63728   jresult = result;
63729   return jresult;
63730 }
63731
63732
63733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
63734   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63735   float arg2 ;
63736
63737   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63738   arg2 = (float)jarg2;
63739   if (arg1) (arg1)->right = arg2;
63740 }
63741
63742
63743 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
63744   float jresult ;
63745   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63746   float result;
63747
63748   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63749   result = (float) ((arg1)->right);
63750   jresult = result;
63751   return jresult;
63752 }
63753
63754
63755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
63756   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63757   float arg2 ;
63758
63759   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63760   arg2 = (float)jarg2;
63761   if (arg1) (arg1)->top = arg2;
63762 }
63763
63764
63765 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
63766   float jresult ;
63767   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63768   float result;
63769
63770   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63771   result = (float) ((arg1)->top);
63772   jresult = result;
63773   return jresult;
63774 }
63775
63776
63777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
63778   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63779   float arg2 ;
63780
63781   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63782   arg2 = (float)jarg2;
63783   if (arg1) (arg1)->bottom = arg2;
63784 }
63785
63786
63787 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
63788   float jresult ;
63789   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63790   float result;
63791
63792   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63793   result = (float) ((arg1)->bottom);
63794   jresult = result;
63795   return jresult;
63796 }
63797
63798
63799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
63800   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63801
63802   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63803   {
63804     try {
63805       delete arg1;
63806     } catch (std::out_of_range& e) {
63807       {
63808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63809       };
63810     } catch (std::exception& e) {
63811       {
63812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63813       };
63814     } catch (...) {
63815       {
63816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63817       };
63818     }
63819   }
63820 }
63821
63822
63823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
63824   void * jresult ;
63825   Dali::Toolkit::Alignment *result = 0 ;
63826
63827   {
63828     try {
63829       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
63830     } catch (std::out_of_range& e) {
63831       {
63832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63833       };
63834     } catch (std::exception& e) {
63835       {
63836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63837       };
63838     } catch (...) {
63839       {
63840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63841       };
63842     }
63843   }
63844   jresult = (void *)result;
63845   return jresult;
63846 }
63847
63848
63849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
63850   void * jresult ;
63851   Dali::Toolkit::Alignment::Type arg1 ;
63852   Dali::Toolkit::Alignment::Type arg2 ;
63853   Dali::Toolkit::Alignment result;
63854
63855   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
63856   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
63857   {
63858     try {
63859       result = Dali::Toolkit::Alignment::New(arg1,arg2);
63860     } catch (std::out_of_range& e) {
63861       {
63862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63863       };
63864     } catch (std::exception& e) {
63865       {
63866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63867       };
63868     } catch (...) {
63869       {
63870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63871       };
63872     }
63873   }
63874   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63875   return jresult;
63876 }
63877
63878
63879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
63880   void * jresult ;
63881   Dali::Toolkit::Alignment::Type arg1 ;
63882   Dali::Toolkit::Alignment result;
63883
63884   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
63885   {
63886     try {
63887       result = Dali::Toolkit::Alignment::New(arg1);
63888     } catch (std::out_of_range& e) {
63889       {
63890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63891       };
63892     } catch (std::exception& e) {
63893       {
63894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63895       };
63896     } catch (...) {
63897       {
63898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63899       };
63900     }
63901   }
63902   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63903   return jresult;
63904 }
63905
63906
63907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
63908   void * jresult ;
63909   Dali::Toolkit::Alignment result;
63910
63911   {
63912     try {
63913       result = Dali::Toolkit::Alignment::New();
63914     } catch (std::out_of_range& e) {
63915       {
63916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63917       };
63918     } catch (std::exception& e) {
63919       {
63920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63921       };
63922     } catch (...) {
63923       {
63924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63925       };
63926     }
63927   }
63928   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63929   return jresult;
63930 }
63931
63932
63933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
63934   void * jresult ;
63935   Dali::Toolkit::Alignment *arg1 = 0 ;
63936   Dali::Toolkit::Alignment *result = 0 ;
63937
63938   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63939   if (!arg1) {
63940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
63941     return 0;
63942   }
63943   {
63944     try {
63945       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
63946     } catch (std::out_of_range& e) {
63947       {
63948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63949       };
63950     } catch (std::exception& e) {
63951       {
63952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63953       };
63954     } catch (...) {
63955       {
63956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63957       };
63958     }
63959   }
63960   jresult = (void *)result;
63961   return jresult;
63962 }
63963
63964
63965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
63966   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63967
63968   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63969   {
63970     try {
63971       delete arg1;
63972     } catch (std::out_of_range& e) {
63973       {
63974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63975       };
63976     } catch (std::exception& e) {
63977       {
63978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63979       };
63980     } catch (...) {
63981       {
63982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63983       };
63984     }
63985   }
63986 }
63987
63988
63989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
63990   void * jresult ;
63991   Dali::BaseHandle arg1 ;
63992   Dali::BaseHandle *argp1 ;
63993   Dali::Toolkit::Alignment result;
63994
63995   argp1 = (Dali::BaseHandle *)jarg1;
63996   if (!argp1) {
63997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63998     return 0;
63999   }
64000   arg1 = *argp1;
64001   {
64002     try {
64003       result = Dali::Toolkit::Alignment::DownCast(arg1);
64004     } catch (std::out_of_range& e) {
64005       {
64006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64007       };
64008     } catch (std::exception& e) {
64009       {
64010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64011       };
64012     } catch (...) {
64013       {
64014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64015       };
64016     }
64017   }
64018   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64019   return jresult;
64020 }
64021
64022
64023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
64024   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64025   Dali::Toolkit::Alignment::Type arg2 ;
64026
64027   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64028   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64029   {
64030     try {
64031       (arg1)->SetAlignmentType(arg2);
64032     } catch (std::out_of_range& e) {
64033       {
64034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64035       };
64036     } catch (std::exception& e) {
64037       {
64038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64039       };
64040     } catch (...) {
64041       {
64042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64043       };
64044     }
64045   }
64046 }
64047
64048
64049 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
64050   int jresult ;
64051   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64052   Dali::Toolkit::Alignment::Type result;
64053
64054   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64055   {
64056     try {
64057       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
64058     } catch (std::out_of_range& e) {
64059       {
64060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64061       };
64062     } catch (std::exception& e) {
64063       {
64064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64065       };
64066     } catch (...) {
64067       {
64068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64069       };
64070     }
64071   }
64072   jresult = (int)result;
64073   return jresult;
64074 }
64075
64076
64077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
64078   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64079   Dali::Toolkit::Alignment::Scaling arg2 ;
64080
64081   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64082   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
64083   {
64084     try {
64085       (arg1)->SetScaling(arg2);
64086     } catch (std::out_of_range& e) {
64087       {
64088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64089       };
64090     } catch (std::exception& e) {
64091       {
64092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64093       };
64094     } catch (...) {
64095       {
64096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64097       };
64098     }
64099   }
64100 }
64101
64102
64103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
64104   int jresult ;
64105   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64106   Dali::Toolkit::Alignment::Scaling result;
64107
64108   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64109   {
64110     try {
64111       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
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 = (int)result;
64127   return jresult;
64128 }
64129
64130
64131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
64132   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64133   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
64134
64135   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64136   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
64137   if (!arg2) {
64138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
64139     return ;
64140   }
64141   {
64142     try {
64143       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
64144     } catch (std::out_of_range& e) {
64145       {
64146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64147       };
64148     } catch (std::exception& e) {
64149       {
64150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64151       };
64152     } catch (...) {
64153       {
64154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64155       };
64156     }
64157   }
64158 }
64159
64160
64161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
64162   void * jresult ;
64163   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64164   Dali::Toolkit::Alignment::Padding *result = 0 ;
64165
64166   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64167   {
64168     try {
64169       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
64170     } catch (std::out_of_range& e) {
64171       {
64172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64173       };
64174     } catch (std::exception& e) {
64175       {
64176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64177       };
64178     } catch (...) {
64179       {
64180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64181       };
64182     }
64183   }
64184   jresult = (void *)result;
64185   return jresult;
64186 }
64187
64188
64189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
64190   void * jresult ;
64191   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64192   Dali::Toolkit::Alignment *arg2 = 0 ;
64193   Dali::Toolkit::Alignment *result = 0 ;
64194
64195   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64196   arg2 = (Dali::Toolkit::Alignment *)jarg2;
64197   if (!arg2) {
64198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
64199     return 0;
64200   }
64201   {
64202     try {
64203       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
64204     } catch (std::out_of_range& e) {
64205       {
64206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64207       };
64208     } catch (std::exception& e) {
64209       {
64210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64211       };
64212     } catch (...) {
64213       {
64214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64215       };
64216     }
64217   }
64218   jresult = (void *)result;
64219   return jresult;
64220 }
64221
64222
64223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
64224   int jresult ;
64225   int result;
64226
64227   result = (int)Dali::Toolkit::Button::Property::DISABLED;
64228   jresult = (int)result;
64229   return jresult;
64230 }
64231
64232
64233 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
64234   int jresult ;
64235   int result;
64236
64237   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
64238   jresult = (int)result;
64239   return jresult;
64240 }
64241
64242
64243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
64244   int jresult ;
64245   int result;
64246
64247   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
64248   jresult = (int)result;
64249   return jresult;
64250 }
64251
64252
64253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
64254   int jresult ;
64255   int result;
64256
64257   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
64258   jresult = (int)result;
64259   return jresult;
64260 }
64261
64262
64263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
64264   int jresult ;
64265   int result;
64266
64267   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
64268   jresult = (int)result;
64269   return jresult;
64270 }
64271
64272
64273 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
64274   int jresult ;
64275   int result;
64276
64277   result = (int)Dali::Toolkit::Button::Property::SELECTED;
64278   jresult = (int)result;
64279   return jresult;
64280 }
64281
64282
64283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
64284   int jresult ;
64285   int result;
64286
64287   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
64288   jresult = (int)result;
64289   return jresult;
64290 }
64291
64292
64293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
64294   int jresult ;
64295   int result;
64296
64297   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
64298   jresult = (int)result;
64299   return jresult;
64300 }
64301
64302
64303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
64304   int jresult ;
64305   int result;
64306
64307   result = (int)Dali::Toolkit::Button::Property::LABEL;
64308   jresult = (int)result;
64309   return jresult;
64310 }
64311
64312
64313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
64314   int jresult ;
64315   int result;
64316
64317   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
64318   jresult = (int)result;
64319   return jresult;
64320 }
64321
64322
64323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
64324   void * jresult ;
64325   Dali::Toolkit::Button::Property *result = 0 ;
64326
64327   {
64328     try {
64329       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
64330     } catch (std::out_of_range& e) {
64331       {
64332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64333       };
64334     } catch (std::exception& e) {
64335       {
64336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64337       };
64338     } catch (...) {
64339       {
64340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64341       };
64342     }
64343   }
64344   jresult = (void *)result;
64345   return jresult;
64346 }
64347
64348
64349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
64350   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
64351
64352   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
64353   {
64354     try {
64355       delete arg1;
64356     } catch (std::out_of_range& e) {
64357       {
64358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64359       };
64360     } catch (std::exception& e) {
64361       {
64362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64363       };
64364     } catch (...) {
64365       {
64366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64367       };
64368     }
64369   }
64370 }
64371
64372
64373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
64374   void * jresult ;
64375   Dali::Toolkit::Button *result = 0 ;
64376
64377   {
64378     try {
64379       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
64380     } catch (std::out_of_range& e) {
64381       {
64382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64383       };
64384     } catch (std::exception& e) {
64385       {
64386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64387       };
64388     } catch (...) {
64389       {
64390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64391       };
64392     }
64393   }
64394   jresult = (void *)result;
64395   return jresult;
64396 }
64397
64398
64399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
64400   void * jresult ;
64401   Dali::Toolkit::Button *arg1 = 0 ;
64402   Dali::Toolkit::Button *result = 0 ;
64403
64404   arg1 = (Dali::Toolkit::Button *)jarg1;
64405   if (!arg1) {
64406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
64407     return 0;
64408   }
64409   {
64410     try {
64411       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
64412     } catch (std::out_of_range& e) {
64413       {
64414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64415       };
64416     } catch (std::exception& e) {
64417       {
64418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64419       };
64420     } catch (...) {
64421       {
64422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64423       };
64424     }
64425   }
64426   jresult = (void *)result;
64427   return jresult;
64428 }
64429
64430
64431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
64432   void * jresult ;
64433   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64434   Dali::Toolkit::Button *arg2 = 0 ;
64435   Dali::Toolkit::Button *result = 0 ;
64436
64437   arg1 = (Dali::Toolkit::Button *)jarg1;
64438   arg2 = (Dali::Toolkit::Button *)jarg2;
64439   if (!arg2) {
64440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
64441     return 0;
64442   }
64443   {
64444     try {
64445       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
64446     } catch (std::out_of_range& e) {
64447       {
64448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64449       };
64450     } catch (std::exception& e) {
64451       {
64452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64453       };
64454     } catch (...) {
64455       {
64456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64457       };
64458     }
64459   }
64460   jresult = (void *)result;
64461   return jresult;
64462 }
64463
64464
64465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
64466   void * jresult ;
64467   Dali::BaseHandle arg1 ;
64468   Dali::BaseHandle *argp1 ;
64469   Dali::Toolkit::Button result;
64470
64471   argp1 = (Dali::BaseHandle *)jarg1;
64472   if (!argp1) {
64473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64474     return 0;
64475   }
64476   arg1 = *argp1;
64477   {
64478     try {
64479       result = Dali::Toolkit::Button::DownCast(arg1);
64480     } catch (std::out_of_range& e) {
64481       {
64482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64483       };
64484     } catch (std::exception& e) {
64485       {
64486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64487       };
64488     } catch (...) {
64489       {
64490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64491       };
64492     }
64493   }
64494   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
64495   return jresult;
64496 }
64497
64498
64499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
64500   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64501
64502   arg1 = (Dali::Toolkit::Button *)jarg1;
64503   {
64504     try {
64505       delete arg1;
64506     } catch (std::out_of_range& e) {
64507       {
64508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64509       };
64510     } catch (std::exception& e) {
64511       {
64512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64513       };
64514     } catch (...) {
64515       {
64516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64517       };
64518     }
64519   }
64520 }
64521
64522
64523 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
64524   unsigned int jresult ;
64525   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64526   bool result;
64527
64528   arg1 = (Dali::Toolkit::Button *)jarg1;
64529   {
64530     try {
64531       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
64532     } catch (std::out_of_range& e) {
64533       {
64534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64535       };
64536     } catch (std::exception& e) {
64537       {
64538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64539       };
64540     } catch (...) {
64541       {
64542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64543       };
64544     }
64545   }
64546   jresult = result;
64547   return jresult;
64548 }
64549
64550
64551 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
64552   unsigned int jresult ;
64553   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64554   bool result;
64555
64556   arg1 = (Dali::Toolkit::Button *)jarg1;
64557   {
64558     try {
64559       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
64560     } catch (std::out_of_range& e) {
64561       {
64562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64563       };
64564     } catch (std::exception& e) {
64565       {
64566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64567       };
64568     } catch (...) {
64569       {
64570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64571       };
64572     }
64573   }
64574   jresult = result;
64575   return jresult;
64576 }
64577
64578
64579 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
64580   float jresult ;
64581   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64582   float result;
64583
64584   arg1 = (Dali::Toolkit::Button *)jarg1;
64585   {
64586     try {
64587       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
64588     } catch (std::out_of_range& e) {
64589       {
64590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64591       };
64592     } catch (std::exception& e) {
64593       {
64594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64595       };
64596     } catch (...) {
64597       {
64598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64599       };
64600     }
64601   }
64602   jresult = result;
64603   return jresult;
64604 }
64605
64606
64607 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
64608   float jresult ;
64609   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64610   float result;
64611
64612   arg1 = (Dali::Toolkit::Button *)jarg1;
64613   {
64614     try {
64615       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
64616     } catch (std::out_of_range& e) {
64617       {
64618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64619       };
64620     } catch (std::exception& e) {
64621       {
64622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64623       };
64624     } catch (...) {
64625       {
64626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64627       };
64628     }
64629   }
64630   jresult = result;
64631   return jresult;
64632 }
64633
64634
64635 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
64636   unsigned int jresult ;
64637   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64638   bool result;
64639
64640   arg1 = (Dali::Toolkit::Button *)jarg1;
64641   {
64642     try {
64643       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
64644     } catch (std::out_of_range& e) {
64645       {
64646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64647       };
64648     } catch (std::exception& e) {
64649       {
64650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64651       };
64652     } catch (...) {
64653       {
64654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64655       };
64656     }
64657   }
64658   jresult = result;
64659   return jresult;
64660 }
64661
64662
64663 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
64664   unsigned int jresult ;
64665   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64666   bool result;
64667
64668   arg1 = (Dali::Toolkit::Button *)jarg1;
64669   {
64670     try {
64671       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
64672     } catch (std::out_of_range& e) {
64673       {
64674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64675       };
64676     } catch (std::exception& e) {
64677       {
64678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64679       };
64680     } catch (...) {
64681       {
64682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64683       };
64684     }
64685   }
64686   jresult = result;
64687   return jresult;
64688 }
64689
64690
64691 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
64692   float jresult ;
64693   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64694   float result;
64695
64696   arg1 = (Dali::Toolkit::Button *)jarg1;
64697   {
64698     try {
64699       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
64700     } catch (std::out_of_range& e) {
64701       {
64702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64703       };
64704     } catch (std::exception& e) {
64705       {
64706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64707       };
64708     } catch (...) {
64709       {
64710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64711       };
64712     }
64713   }
64714   jresult = result;
64715   return jresult;
64716 }
64717
64718
64719 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
64720   char * jresult ;
64721   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64722   std::string result;
64723
64724   arg1 = (Dali::Toolkit::Button *)jarg1;
64725   {
64726     try {
64727       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
64728     } catch (std::out_of_range& e) {
64729       {
64730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64731       };
64732     } catch (std::exception& e) {
64733       {
64734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64735       };
64736     } catch (...) {
64737       {
64738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64739       };
64740     }
64741   }
64742   jresult = SWIG_csharp_string_callback((&result)->c_str());
64743   return jresult;
64744 }
64745
64746
64747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
64748   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64749   Dali::Actor arg2 ;
64750   Dali::Actor *argp2 ;
64751
64752   arg1 = (Dali::Toolkit::Button *)jarg1;
64753   argp2 = (Dali::Actor *)jarg2;
64754   if (!argp2) {
64755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
64756     return ;
64757   }
64758   arg2 = *argp2;
64759   {
64760     try {
64761       (arg1)->SetLabel(arg2);
64762     } catch (std::out_of_range& e) {
64763       {
64764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64765       };
64766     } catch (std::exception& e) {
64767       {
64768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64769       };
64770     } catch (...) {
64771       {
64772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64773       };
64774     }
64775   }
64776 }
64777
64778
64779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
64780   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64781   Dali::Image arg2 ;
64782   Dali::Image *argp2 ;
64783
64784   arg1 = (Dali::Toolkit::Button *)jarg1;
64785   argp2 = (Dali::Image *)jarg2;
64786   if (!argp2) {
64787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
64788     return ;
64789   }
64790   arg2 = *argp2;
64791   {
64792     try {
64793       (arg1)->SetButtonImage(arg2);
64794     } catch (std::out_of_range& e) {
64795       {
64796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64797       };
64798     } catch (std::exception& e) {
64799       {
64800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64801       };
64802     } catch (...) {
64803       {
64804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64805       };
64806     }
64807   }
64808 }
64809
64810
64811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
64812   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64813   Dali::Image arg2 ;
64814   Dali::Image *argp2 ;
64815
64816   arg1 = (Dali::Toolkit::Button *)jarg1;
64817   argp2 = (Dali::Image *)jarg2;
64818   if (!argp2) {
64819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
64820     return ;
64821   }
64822   arg2 = *argp2;
64823   {
64824     try {
64825       (arg1)->SetSelectedImage(arg2);
64826     } catch (std::out_of_range& e) {
64827       {
64828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64829       };
64830     } catch (std::exception& e) {
64831       {
64832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64833       };
64834     } catch (...) {
64835       {
64836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64837       };
64838     }
64839   }
64840 }
64841
64842
64843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
64844   void * jresult ;
64845   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64846   Dali::Actor result;
64847
64848   arg1 = (Dali::Toolkit::Button *)jarg1;
64849   {
64850     try {
64851       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
64852     } catch (std::out_of_range& e) {
64853       {
64854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64855       };
64856     } catch (std::exception& e) {
64857       {
64858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64859       };
64860     } catch (...) {
64861       {
64862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64863       };
64864     }
64865   }
64866   jresult = new Dali::Actor((const Dali::Actor &)result);
64867   return jresult;
64868 }
64869
64870
64871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
64872   void * jresult ;
64873   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64874   Dali::Actor result;
64875
64876   arg1 = (Dali::Toolkit::Button *)jarg1;
64877   {
64878     try {
64879       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
64880     } catch (std::out_of_range& e) {
64881       {
64882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64883       };
64884     } catch (std::exception& e) {
64885       {
64886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64887       };
64888     } catch (...) {
64889       {
64890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64891       };
64892     }
64893   }
64894   jresult = new Dali::Actor((const Dali::Actor &)result);
64895   return jresult;
64896 }
64897
64898
64899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
64900   void * jresult ;
64901   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64902   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64903
64904   arg1 = (Dali::Toolkit::Button *)jarg1;
64905   {
64906     try {
64907       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
64908     } catch (std::out_of_range& e) {
64909       {
64910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64911       };
64912     } catch (std::exception& e) {
64913       {
64914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64915       };
64916     } catch (...) {
64917       {
64918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64919       };
64920     }
64921   }
64922   jresult = (void *)result;
64923   return jresult;
64924 }
64925
64926
64927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
64928   void * jresult ;
64929   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64930   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64931
64932   arg1 = (Dali::Toolkit::Button *)jarg1;
64933   {
64934     try {
64935       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
64936     } catch (std::out_of_range& e) {
64937       {
64938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64939       };
64940     } catch (std::exception& e) {
64941       {
64942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64943       };
64944     } catch (...) {
64945       {
64946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64947       };
64948     }
64949   }
64950   jresult = (void *)result;
64951   return jresult;
64952 }
64953
64954
64955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
64956   void * jresult ;
64957   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64958   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64959
64960   arg1 = (Dali::Toolkit::Button *)jarg1;
64961   {
64962     try {
64963       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
64964     } catch (std::out_of_range& e) {
64965       {
64966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64967       };
64968     } catch (std::exception& e) {
64969       {
64970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64971       };
64972     } catch (...) {
64973       {
64974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64975       };
64976     }
64977   }
64978   jresult = (void *)result;
64979   return jresult;
64980 }
64981
64982
64983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
64984   void * jresult ;
64985   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64986   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64987
64988   arg1 = (Dali::Toolkit::Button *)jarg1;
64989   {
64990     try {
64991       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
64992     } catch (std::out_of_range& e) {
64993       {
64994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64995       };
64996     } catch (std::exception& e) {
64997       {
64998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64999       };
65000     } catch (...) {
65001       {
65002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65003       };
65004     }
65005   }
65006   jresult = (void *)result;
65007   return jresult;
65008 }
65009
65010
65011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
65012   void * jresult ;
65013   Dali::Toolkit::CheckBoxButton *result = 0 ;
65014
65015   {
65016     try {
65017       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
65018     } catch (std::out_of_range& e) {
65019       {
65020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65021       };
65022     } catch (std::exception& e) {
65023       {
65024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65025       };
65026     } catch (...) {
65027       {
65028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65029       };
65030     }
65031   }
65032   jresult = (void *)result;
65033   return jresult;
65034 }
65035
65036
65037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
65038   void * jresult ;
65039   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
65040   Dali::Toolkit::CheckBoxButton *result = 0 ;
65041
65042   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65043   if (!arg1) {
65044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65045     return 0;
65046   }
65047   {
65048     try {
65049       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
65050     } catch (std::out_of_range& e) {
65051       {
65052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65053       };
65054     } catch (std::exception& e) {
65055       {
65056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65057       };
65058     } catch (...) {
65059       {
65060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65061       };
65062     }
65063   }
65064   jresult = (void *)result;
65065   return jresult;
65066 }
65067
65068
65069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
65070   void * jresult ;
65071   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65072   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
65073   Dali::Toolkit::CheckBoxButton *result = 0 ;
65074
65075   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65076   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
65077   if (!arg2) {
65078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65079     return 0;
65080   }
65081   {
65082     try {
65083       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
65084     } catch (std::out_of_range& e) {
65085       {
65086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65087       };
65088     } catch (std::exception& e) {
65089       {
65090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65091       };
65092     } catch (...) {
65093       {
65094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65095       };
65096     }
65097   }
65098   jresult = (void *)result;
65099   return jresult;
65100 }
65101
65102
65103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
65104   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65105
65106   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65107   {
65108     try {
65109       delete arg1;
65110     } catch (std::out_of_range& e) {
65111       {
65112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65113       };
65114     } catch (std::exception& e) {
65115       {
65116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65117       };
65118     } catch (...) {
65119       {
65120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65121       };
65122     }
65123   }
65124 }
65125
65126
65127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
65128   void * jresult ;
65129   Dali::Toolkit::CheckBoxButton result;
65130
65131   {
65132     try {
65133       result = Dali::Toolkit::CheckBoxButton::New();
65134     } catch (std::out_of_range& e) {
65135       {
65136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65137       };
65138     } catch (std::exception& e) {
65139       {
65140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65141       };
65142     } catch (...) {
65143       {
65144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65145       };
65146     }
65147   }
65148   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65149   return jresult;
65150 }
65151
65152
65153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
65154   void * jresult ;
65155   Dali::BaseHandle arg1 ;
65156   Dali::BaseHandle *argp1 ;
65157   Dali::Toolkit::CheckBoxButton result;
65158
65159   argp1 = (Dali::BaseHandle *)jarg1;
65160   if (!argp1) {
65161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65162     return 0;
65163   }
65164   arg1 = *argp1;
65165   {
65166     try {
65167       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
65168     } catch (std::out_of_range& e) {
65169       {
65170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65171       };
65172     } catch (std::exception& e) {
65173       {
65174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65175       };
65176     } catch (...) {
65177       {
65178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65179       };
65180     }
65181   }
65182   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65183   return jresult;
65184 }
65185
65186
65187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
65188   int jresult ;
65189   int result;
65190
65191   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
65192   jresult = (int)result;
65193   return jresult;
65194 }
65195
65196
65197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
65198   int jresult ;
65199   int result;
65200
65201   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
65202   jresult = (int)result;
65203   return jresult;
65204 }
65205
65206
65207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
65208   int jresult ;
65209   int result;
65210
65211   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
65212   jresult = (int)result;
65213   return jresult;
65214 }
65215
65216
65217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
65218   int jresult ;
65219   int result;
65220
65221   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
65222   jresult = (int)result;
65223   return jresult;
65224 }
65225
65226
65227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
65228   int jresult ;
65229   int result;
65230
65231   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
65232   jresult = (int)result;
65233   return jresult;
65234 }
65235
65236
65237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
65238   void * jresult ;
65239   Dali::Toolkit::PushButton::Property *result = 0 ;
65240
65241   {
65242     try {
65243       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
65244     } catch (std::out_of_range& e) {
65245       {
65246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65247       };
65248     } catch (std::exception& e) {
65249       {
65250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65251       };
65252     } catch (...) {
65253       {
65254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65255       };
65256     }
65257   }
65258   jresult = (void *)result;
65259   return jresult;
65260 }
65261
65262
65263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
65264   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
65265
65266   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
65267   {
65268     try {
65269       delete arg1;
65270     } catch (std::out_of_range& e) {
65271       {
65272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65273       };
65274     } catch (std::exception& e) {
65275       {
65276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65277       };
65278     } catch (...) {
65279       {
65280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65281       };
65282     }
65283   }
65284 }
65285
65286
65287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
65288   void * jresult ;
65289   Dali::Toolkit::PushButton *result = 0 ;
65290
65291   {
65292     try {
65293       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
65294     } catch (std::out_of_range& e) {
65295       {
65296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65297       };
65298     } catch (std::exception& e) {
65299       {
65300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65301       };
65302     } catch (...) {
65303       {
65304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65305       };
65306     }
65307   }
65308   jresult = (void *)result;
65309   return jresult;
65310 }
65311
65312
65313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
65314   void * jresult ;
65315   Dali::Toolkit::PushButton *arg1 = 0 ;
65316   Dali::Toolkit::PushButton *result = 0 ;
65317
65318   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65319   if (!arg1) {
65320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
65321     return 0;
65322   }
65323   {
65324     try {
65325       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
65326     } catch (std::out_of_range& e) {
65327       {
65328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65329       };
65330     } catch (std::exception& e) {
65331       {
65332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65333       };
65334     } catch (...) {
65335       {
65336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65337       };
65338     }
65339   }
65340   jresult = (void *)result;
65341   return jresult;
65342 }
65343
65344
65345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
65346   void * jresult ;
65347   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65348   Dali::Toolkit::PushButton *arg2 = 0 ;
65349   Dali::Toolkit::PushButton *result = 0 ;
65350
65351   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65352   arg2 = (Dali::Toolkit::PushButton *)jarg2;
65353   if (!arg2) {
65354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
65355     return 0;
65356   }
65357   {
65358     try {
65359       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
65360     } catch (std::out_of_range& e) {
65361       {
65362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65363       };
65364     } catch (std::exception& e) {
65365       {
65366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65367       };
65368     } catch (...) {
65369       {
65370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65371       };
65372     }
65373   }
65374   jresult = (void *)result;
65375   return jresult;
65376 }
65377
65378
65379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
65380   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65381
65382   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65383   {
65384     try {
65385       delete arg1;
65386     } catch (std::out_of_range& e) {
65387       {
65388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65389       };
65390     } catch (std::exception& e) {
65391       {
65392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65393       };
65394     } catch (...) {
65395       {
65396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65397       };
65398     }
65399   }
65400 }
65401
65402
65403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
65404   void * jresult ;
65405   Dali::Toolkit::PushButton result;
65406
65407   {
65408     try {
65409       result = Dali::Toolkit::PushButton::New();
65410     } catch (std::out_of_range& e) {
65411       {
65412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65413       };
65414     } catch (std::exception& e) {
65415       {
65416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65417       };
65418     } catch (...) {
65419       {
65420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65421       };
65422     }
65423   }
65424   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65425   return jresult;
65426 }
65427
65428
65429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
65430   void * jresult ;
65431   Dali::BaseHandle arg1 ;
65432   Dali::BaseHandle *argp1 ;
65433   Dali::Toolkit::PushButton result;
65434
65435   argp1 = (Dali::BaseHandle *)jarg1;
65436   if (!argp1) {
65437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65438     return 0;
65439   }
65440   arg1 = *argp1;
65441   {
65442     try {
65443       result = Dali::Toolkit::PushButton::DownCast(arg1);
65444     } catch (std::out_of_range& e) {
65445       {
65446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65447       };
65448     } catch (std::exception& e) {
65449       {
65450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65451       };
65452     } catch (...) {
65453       {
65454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65455       };
65456     }
65457   }
65458   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65459   return jresult;
65460 }
65461
65462
65463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
65464   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65465   Dali::Image arg2 ;
65466   Dali::Image *argp2 ;
65467
65468   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65469   argp2 = (Dali::Image *)jarg2;
65470   if (!argp2) {
65471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65472     return ;
65473   }
65474   arg2 = *argp2;
65475   {
65476     try {
65477       (arg1)->SetButtonImage(arg2);
65478     } catch (std::out_of_range& e) {
65479       {
65480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65481       };
65482     } catch (std::exception& e) {
65483       {
65484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65485       };
65486     } catch (...) {
65487       {
65488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65489       };
65490     }
65491   }
65492 }
65493
65494
65495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
65496   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65497   Dali::Actor arg2 ;
65498   Dali::Actor *argp2 ;
65499
65500   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65501   argp2 = (Dali::Actor *)jarg2;
65502   if (!argp2) {
65503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65504     return ;
65505   }
65506   arg2 = *argp2;
65507   {
65508     try {
65509       (arg1)->SetButtonImage(arg2);
65510     } catch (std::out_of_range& e) {
65511       {
65512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65513       };
65514     } catch (std::exception& e) {
65515       {
65516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65517       };
65518     } catch (...) {
65519       {
65520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65521       };
65522     }
65523   }
65524 }
65525
65526
65527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
65528   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65529   Dali::Actor arg2 ;
65530   Dali::Actor *argp2 ;
65531
65532   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65533   argp2 = (Dali::Actor *)jarg2;
65534   if (!argp2) {
65535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65536     return ;
65537   }
65538   arg2 = *argp2;
65539   {
65540     try {
65541       (arg1)->SetBackgroundImage(arg2);
65542     } catch (std::out_of_range& e) {
65543       {
65544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65545       };
65546     } catch (std::exception& e) {
65547       {
65548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65549       };
65550     } catch (...) {
65551       {
65552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65553       };
65554     }
65555   }
65556 }
65557
65558
65559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
65560   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65561   Dali::Image arg2 ;
65562   Dali::Image *argp2 ;
65563
65564   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65565   argp2 = (Dali::Image *)jarg2;
65566   if (!argp2) {
65567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65568     return ;
65569   }
65570   arg2 = *argp2;
65571   {
65572     try {
65573       (arg1)->SetSelectedImage(arg2);
65574     } catch (std::out_of_range& e) {
65575       {
65576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65577       };
65578     } catch (std::exception& e) {
65579       {
65580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65581       };
65582     } catch (...) {
65583       {
65584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65585       };
65586     }
65587   }
65588 }
65589
65590
65591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
65592   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65593   Dali::Actor arg2 ;
65594   Dali::Actor *argp2 ;
65595
65596   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65597   argp2 = (Dali::Actor *)jarg2;
65598   if (!argp2) {
65599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65600     return ;
65601   }
65602   arg2 = *argp2;
65603   {
65604     try {
65605       (arg1)->SetSelectedImage(arg2);
65606     } catch (std::out_of_range& e) {
65607       {
65608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65609       };
65610     } catch (std::exception& e) {
65611       {
65612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65613       };
65614     } catch (...) {
65615       {
65616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65617       };
65618     }
65619   }
65620 }
65621
65622
65623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
65624   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65625   Dali::Actor arg2 ;
65626   Dali::Actor *argp2 ;
65627
65628   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65629   argp2 = (Dali::Actor *)jarg2;
65630   if (!argp2) {
65631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65632     return ;
65633   }
65634   arg2 = *argp2;
65635   {
65636     try {
65637       (arg1)->SetSelectedBackgroundImage(arg2);
65638     } catch (std::out_of_range& e) {
65639       {
65640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65641       };
65642     } catch (std::exception& e) {
65643       {
65644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65645       };
65646     } catch (...) {
65647       {
65648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65649       };
65650     }
65651   }
65652 }
65653
65654
65655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
65656   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65657   Dali::Actor arg2 ;
65658   Dali::Actor *argp2 ;
65659
65660   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65661   argp2 = (Dali::Actor *)jarg2;
65662   if (!argp2) {
65663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65664     return ;
65665   }
65666   arg2 = *argp2;
65667   {
65668     try {
65669       (arg1)->SetDisabledBackgroundImage(arg2);
65670     } catch (std::out_of_range& e) {
65671       {
65672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65673       };
65674     } catch (std::exception& e) {
65675       {
65676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65677       };
65678     } catch (...) {
65679       {
65680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65681       };
65682     }
65683   }
65684 }
65685
65686
65687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
65688   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65689   Dali::Actor arg2 ;
65690   Dali::Actor *argp2 ;
65691
65692   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65693   argp2 = (Dali::Actor *)jarg2;
65694   if (!argp2) {
65695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65696     return ;
65697   }
65698   arg2 = *argp2;
65699   {
65700     try {
65701       (arg1)->SetDisabledImage(arg2);
65702     } catch (std::out_of_range& e) {
65703       {
65704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65705       };
65706     } catch (std::exception& e) {
65707       {
65708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65709       };
65710     } catch (...) {
65711       {
65712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65713       };
65714     }
65715   }
65716 }
65717
65718
65719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
65720   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65721   Dali::Actor arg2 ;
65722   Dali::Actor *argp2 ;
65723
65724   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65725   argp2 = (Dali::Actor *)jarg2;
65726   if (!argp2) {
65727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65728     return ;
65729   }
65730   arg2 = *argp2;
65731   {
65732     try {
65733       (arg1)->SetDisabledSelectedImage(arg2);
65734     } catch (std::out_of_range& e) {
65735       {
65736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65737       };
65738     } catch (std::exception& e) {
65739       {
65740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65741       };
65742     } catch (...) {
65743       {
65744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65745       };
65746     }
65747   }
65748 }
65749
65750
65751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
65752   void * jresult ;
65753   Dali::Toolkit::RadioButton *result = 0 ;
65754
65755   {
65756     try {
65757       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
65758     } catch (std::out_of_range& e) {
65759       {
65760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65761       };
65762     } catch (std::exception& e) {
65763       {
65764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65765       };
65766     } catch (...) {
65767       {
65768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65769       };
65770     }
65771   }
65772   jresult = (void *)result;
65773   return jresult;
65774 }
65775
65776
65777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
65778   void * jresult ;
65779   Dali::Toolkit::RadioButton *arg1 = 0 ;
65780   Dali::Toolkit::RadioButton *result = 0 ;
65781
65782   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65783   if (!arg1) {
65784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65785     return 0;
65786   }
65787   {
65788     try {
65789       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
65790     } catch (std::out_of_range& e) {
65791       {
65792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65793       };
65794     } catch (std::exception& e) {
65795       {
65796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65797       };
65798     } catch (...) {
65799       {
65800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65801       };
65802     }
65803   }
65804   jresult = (void *)result;
65805   return jresult;
65806 }
65807
65808
65809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
65810   void * jresult ;
65811   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
65812   Dali::Toolkit::RadioButton *arg2 = 0 ;
65813   Dali::Toolkit::RadioButton *result = 0 ;
65814
65815   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65816   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
65817   if (!arg2) {
65818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65819     return 0;
65820   }
65821   {
65822     try {
65823       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
65824     } catch (std::out_of_range& e) {
65825       {
65826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65827       };
65828     } catch (std::exception& e) {
65829       {
65830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65831       };
65832     } catch (...) {
65833       {
65834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65835       };
65836     }
65837   }
65838   jresult = (void *)result;
65839   return jresult;
65840 }
65841
65842
65843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
65844   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
65845
65846   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65847   {
65848     try {
65849       delete arg1;
65850     } catch (std::out_of_range& e) {
65851       {
65852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65853       };
65854     } catch (std::exception& e) {
65855       {
65856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65857       };
65858     } catch (...) {
65859       {
65860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65861       };
65862     }
65863   }
65864 }
65865
65866
65867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
65868   void * jresult ;
65869   Dali::Toolkit::RadioButton result;
65870
65871   {
65872     try {
65873       result = Dali::Toolkit::RadioButton::New();
65874     } catch (std::out_of_range& e) {
65875       {
65876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65877       };
65878     } catch (std::exception& e) {
65879       {
65880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65881       };
65882     } catch (...) {
65883       {
65884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65885       };
65886     }
65887   }
65888   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65889   return jresult;
65890 }
65891
65892
65893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
65894   void * jresult ;
65895   std::string *arg1 = 0 ;
65896   Dali::Toolkit::RadioButton result;
65897
65898   if (!jarg1) {
65899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
65900     return 0;
65901   }
65902   std::string arg1_str(jarg1);
65903   arg1 = &arg1_str;
65904   {
65905     try {
65906       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
65907     } catch (std::out_of_range& e) {
65908       {
65909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65910       };
65911     } catch (std::exception& e) {
65912       {
65913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65914       };
65915     } catch (...) {
65916       {
65917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65918       };
65919     }
65920   }
65921   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65922
65923   //argout typemap for const std::string&
65924
65925   return jresult;
65926 }
65927
65928
65929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
65930   void * jresult ;
65931   Dali::BaseHandle arg1 ;
65932   Dali::BaseHandle *argp1 ;
65933   Dali::Toolkit::RadioButton result;
65934
65935   argp1 = (Dali::BaseHandle *)jarg1;
65936   if (!argp1) {
65937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65938     return 0;
65939   }
65940   arg1 = *argp1;
65941   {
65942     try {
65943       result = Dali::Toolkit::RadioButton::DownCast(arg1);
65944     } catch (std::out_of_range& e) {
65945       {
65946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65947       };
65948     } catch (std::exception& e) {
65949       {
65950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65951       };
65952     } catch (...) {
65953       {
65954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65955       };
65956     }
65957   }
65958   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65959   return jresult;
65960 }
65961
65962
65963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
65964   int jresult ;
65965   int result;
65966
65967   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
65968   jresult = (int)result;
65969   return jresult;
65970 }
65971
65972
65973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
65974   int jresult ;
65975   int result;
65976
65977   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
65978   jresult = (int)result;
65979   return jresult;
65980 }
65981
65982
65983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
65984   int jresult ;
65985   int result;
65986
65987   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
65988   jresult = (int)result;
65989   return jresult;
65990 }
65991
65992
65993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
65994   int jresult ;
65995   int result;
65996
65997   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
65998   jresult = (int)result;
65999   return jresult;
66000 }
66001
66002
66003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
66004   int jresult ;
66005   int result;
66006
66007   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
66008   jresult = (int)result;
66009   return jresult;
66010 }
66011
66012
66013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
66014   int jresult ;
66015   int result;
66016
66017   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
66018   jresult = (int)result;
66019   return jresult;
66020 }
66021
66022
66023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
66024   void * jresult ;
66025   Dali::Toolkit::FlexContainer::Property *result = 0 ;
66026
66027   {
66028     try {
66029       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
66030     } catch (std::out_of_range& e) {
66031       {
66032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66033       };
66034     } catch (std::exception& e) {
66035       {
66036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66037       };
66038     } catch (...) {
66039       {
66040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66041       };
66042     }
66043   }
66044   jresult = (void *)result;
66045   return jresult;
66046 }
66047
66048
66049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
66050   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
66051
66052   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
66053   {
66054     try {
66055       delete arg1;
66056     } catch (std::out_of_range& e) {
66057       {
66058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66059       };
66060     } catch (std::exception& e) {
66061       {
66062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66063       };
66064     } catch (...) {
66065       {
66066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66067       };
66068     }
66069   }
66070 }
66071
66072
66073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
66074   int jresult ;
66075   int result;
66076
66077   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
66078   jresult = (int)result;
66079   return jresult;
66080 }
66081
66082
66083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
66084   int jresult ;
66085   int result;
66086
66087   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
66088   jresult = (int)result;
66089   return jresult;
66090 }
66091
66092
66093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
66094   int jresult ;
66095   int result;
66096
66097   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
66098   jresult = (int)result;
66099   return jresult;
66100 }
66101
66102
66103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
66104   void * jresult ;
66105   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
66106
66107   {
66108     try {
66109       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
66110     } catch (std::out_of_range& e) {
66111       {
66112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66113       };
66114     } catch (std::exception& e) {
66115       {
66116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66117       };
66118     } catch (...) {
66119       {
66120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66121       };
66122     }
66123   }
66124   jresult = (void *)result;
66125   return jresult;
66126 }
66127
66128
66129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
66130   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
66131
66132   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
66133   {
66134     try {
66135       delete arg1;
66136     } catch (std::out_of_range& e) {
66137       {
66138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66139       };
66140     } catch (std::exception& e) {
66141       {
66142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66143       };
66144     } catch (...) {
66145       {
66146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66147       };
66148     }
66149   }
66150 }
66151
66152
66153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
66154   void * jresult ;
66155   Dali::Toolkit::FlexContainer *result = 0 ;
66156
66157   {
66158     try {
66159       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
66160     } catch (std::out_of_range& e) {
66161       {
66162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66163       };
66164     } catch (std::exception& e) {
66165       {
66166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66167       };
66168     } catch (...) {
66169       {
66170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66171       };
66172     }
66173   }
66174   jresult = (void *)result;
66175   return jresult;
66176 }
66177
66178
66179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
66180   void * jresult ;
66181   Dali::Toolkit::FlexContainer *arg1 = 0 ;
66182   Dali::Toolkit::FlexContainer *result = 0 ;
66183
66184   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66185   if (!arg1) {
66186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66187     return 0;
66188   }
66189   {
66190     try {
66191       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
66192     } catch (std::out_of_range& e) {
66193       {
66194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66195       };
66196     } catch (std::exception& e) {
66197       {
66198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66199       };
66200     } catch (...) {
66201       {
66202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66203       };
66204     }
66205   }
66206   jresult = (void *)result;
66207   return jresult;
66208 }
66209
66210
66211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
66212   void * jresult ;
66213   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66214   Dali::Toolkit::FlexContainer *arg2 = 0 ;
66215   Dali::Toolkit::FlexContainer *result = 0 ;
66216
66217   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66218   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
66219   if (!arg2) {
66220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66221     return 0;
66222   }
66223   {
66224     try {
66225       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
66226     } catch (std::out_of_range& e) {
66227       {
66228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66229       };
66230     } catch (std::exception& e) {
66231       {
66232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66233       };
66234     } catch (...) {
66235       {
66236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66237       };
66238     }
66239   }
66240   jresult = (void *)result;
66241   return jresult;
66242 }
66243
66244
66245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
66246   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66247
66248   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66249   {
66250     try {
66251       delete arg1;
66252     } catch (std::out_of_range& e) {
66253       {
66254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66255       };
66256     } catch (std::exception& e) {
66257       {
66258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66259       };
66260     } catch (...) {
66261       {
66262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66263       };
66264     }
66265   }
66266 }
66267
66268
66269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
66270   void * jresult ;
66271   Dali::Toolkit::FlexContainer result;
66272
66273   {
66274     try {
66275       result = Dali::Toolkit::FlexContainer::New();
66276     } catch (std::out_of_range& e) {
66277       {
66278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66279       };
66280     } catch (std::exception& e) {
66281       {
66282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66283       };
66284     } catch (...) {
66285       {
66286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66287       };
66288     }
66289   }
66290   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66291   return jresult;
66292 }
66293
66294
66295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
66296   void * jresult ;
66297   Dali::BaseHandle arg1 ;
66298   Dali::BaseHandle *argp1 ;
66299   Dali::Toolkit::FlexContainer result;
66300
66301   argp1 = (Dali::BaseHandle *)jarg1;
66302   if (!argp1) {
66303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66304     return 0;
66305   }
66306   arg1 = *argp1;
66307   {
66308     try {
66309       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
66310     } catch (std::out_of_range& e) {
66311       {
66312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66313       };
66314     } catch (std::exception& e) {
66315       {
66316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66317       };
66318     } catch (...) {
66319       {
66320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66321       };
66322     }
66323   }
66324   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66325   return jresult;
66326 }
66327
66328
66329 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
66330   int jresult ;
66331   int result;
66332
66333   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
66334   jresult = (int)result;
66335   return jresult;
66336 }
66337
66338
66339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
66340   int jresult ;
66341   int result;
66342
66343   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
66344   jresult = (int)result;
66345   return jresult;
66346 }
66347
66348
66349 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
66350   int jresult ;
66351   int result;
66352
66353   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
66354   jresult = (int)result;
66355   return jresult;
66356 }
66357
66358
66359 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
66360   int jresult ;
66361   int result;
66362
66363   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
66364   jresult = (int)result;
66365   return jresult;
66366 }
66367
66368
66369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
66370   void * jresult ;
66371   Dali::Toolkit::ImageView::Property *result = 0 ;
66372
66373   {
66374     try {
66375       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
66376     } catch (std::out_of_range& e) {
66377       {
66378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66379       };
66380     } catch (std::exception& e) {
66381       {
66382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66383       };
66384     } catch (...) {
66385       {
66386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66387       };
66388     }
66389   }
66390   jresult = (void *)result;
66391   return jresult;
66392 }
66393
66394
66395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
66396   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
66397
66398   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
66399   {
66400     try {
66401       delete arg1;
66402     } catch (std::out_of_range& e) {
66403       {
66404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66405       };
66406     } catch (std::exception& e) {
66407       {
66408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66409       };
66410     } catch (...) {
66411       {
66412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66413       };
66414     }
66415   }
66416 }
66417
66418
66419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
66420   void * jresult ;
66421   Dali::Toolkit::ImageView *result = 0 ;
66422
66423   {
66424     try {
66425       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
66426     } catch (std::out_of_range& e) {
66427       {
66428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66429       };
66430     } catch (std::exception& e) {
66431       {
66432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66433       };
66434     } catch (...) {
66435       {
66436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66437       };
66438     }
66439   }
66440   jresult = (void *)result;
66441   return jresult;
66442 }
66443
66444
66445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
66446   void * jresult ;
66447   Dali::Toolkit::ImageView result;
66448
66449   {
66450     try {
66451       result = Dali::Toolkit::ImageView::New();
66452     } catch (std::out_of_range& e) {
66453       {
66454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66455       };
66456     } catch (std::exception& e) {
66457       {
66458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66459       };
66460     } catch (...) {
66461       {
66462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66463       };
66464     }
66465   }
66466   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66467   return jresult;
66468 }
66469
66470
66471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
66472   void * jresult ;
66473   Dali::Image arg1 ;
66474   Dali::Image *argp1 ;
66475   Dali::Toolkit::ImageView result;
66476
66477   argp1 = (Dali::Image *)jarg1;
66478   if (!argp1) {
66479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
66480     return 0;
66481   }
66482   arg1 = *argp1;
66483   {
66484     try {
66485       result = Dali::Toolkit::ImageView::New(arg1);
66486     } catch (std::out_of_range& e) {
66487       {
66488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66489       };
66490     } catch (std::exception& e) {
66491       {
66492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66493       };
66494     } catch (...) {
66495       {
66496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66497       };
66498     }
66499   }
66500   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66501   return jresult;
66502 }
66503
66504
66505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
66506   void * jresult ;
66507   std::string *arg1 = 0 ;
66508   Dali::Toolkit::ImageView result;
66509
66510   if (!jarg1) {
66511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66512     return 0;
66513   }
66514   std::string arg1_str(jarg1);
66515   arg1 = &arg1_str;
66516   {
66517     try {
66518       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
66519     } catch (std::out_of_range& e) {
66520       {
66521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66522       };
66523     } catch (std::exception& e) {
66524       {
66525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66526       };
66527     } catch (...) {
66528       {
66529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66530       };
66531     }
66532   }
66533   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66534
66535   //argout typemap for const std::string&
66536
66537   return jresult;
66538 }
66539
66540
66541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
66542   void * jresult ;
66543   std::string *arg1 = 0 ;
66544   Dali::ImageDimensions arg2 ;
66545   Dali::ImageDimensions *argp2 ;
66546   Dali::Toolkit::ImageView result;
66547
66548   if (!jarg1) {
66549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66550     return 0;
66551   }
66552   std::string arg1_str(jarg1);
66553   arg1 = &arg1_str;
66554   argp2 = (Dali::ImageDimensions *)jarg2;
66555   if (!argp2) {
66556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
66557     return 0;
66558   }
66559   arg2 = *argp2;
66560   {
66561     try {
66562       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
66563     } catch (std::out_of_range& e) {
66564       {
66565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66566       };
66567     } catch (std::exception& e) {
66568       {
66569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66570       };
66571     } catch (...) {
66572       {
66573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66574       };
66575     }
66576   }
66577   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66578
66579   //argout typemap for const std::string&
66580
66581   return jresult;
66582 }
66583
66584
66585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
66586   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66587
66588   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66589   {
66590     try {
66591       delete arg1;
66592     } catch (std::out_of_range& e) {
66593       {
66594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66595       };
66596     } catch (std::exception& e) {
66597       {
66598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66599       };
66600     } catch (...) {
66601       {
66602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66603       };
66604     }
66605   }
66606 }
66607
66608
66609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
66610   void * jresult ;
66611   Dali::Toolkit::ImageView *arg1 = 0 ;
66612   Dali::Toolkit::ImageView *result = 0 ;
66613
66614   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66615   if (!arg1) {
66616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66617     return 0;
66618   }
66619   {
66620     try {
66621       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
66622     } catch (std::out_of_range& e) {
66623       {
66624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66625       };
66626     } catch (std::exception& e) {
66627       {
66628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66629       };
66630     } catch (...) {
66631       {
66632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66633       };
66634     }
66635   }
66636   jresult = (void *)result;
66637   return jresult;
66638 }
66639
66640
66641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
66642   void * jresult ;
66643   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66644   Dali::Toolkit::ImageView *arg2 = 0 ;
66645   Dali::Toolkit::ImageView *result = 0 ;
66646
66647   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66648   arg2 = (Dali::Toolkit::ImageView *)jarg2;
66649   if (!arg2) {
66650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66651     return 0;
66652   }
66653   {
66654     try {
66655       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
66656     } catch (std::out_of_range& e) {
66657       {
66658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66659       };
66660     } catch (std::exception& e) {
66661       {
66662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66663       };
66664     } catch (...) {
66665       {
66666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66667       };
66668     }
66669   }
66670   jresult = (void *)result;
66671   return jresult;
66672 }
66673
66674
66675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
66676   void * jresult ;
66677   Dali::BaseHandle arg1 ;
66678   Dali::BaseHandle *argp1 ;
66679   Dali::Toolkit::ImageView result;
66680
66681   argp1 = (Dali::BaseHandle *)jarg1;
66682   if (!argp1) {
66683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66684     return 0;
66685   }
66686   arg1 = *argp1;
66687   {
66688     try {
66689       result = Dali::Toolkit::ImageView::DownCast(arg1);
66690     } catch (std::out_of_range& e) {
66691       {
66692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66693       };
66694     } catch (std::exception& e) {
66695       {
66696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66697       };
66698     } catch (...) {
66699       {
66700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66701       };
66702     }
66703   }
66704   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66705   return jresult;
66706 }
66707
66708
66709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
66710   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66711   Dali::Image arg2 ;
66712   Dali::Image *argp2 ;
66713
66714   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66715   argp2 = (Dali::Image *)jarg2;
66716   if (!argp2) {
66717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
66718     return ;
66719   }
66720   arg2 = *argp2;
66721   {
66722     try {
66723       (arg1)->SetImage(arg2);
66724     } catch (std::out_of_range& e) {
66725       {
66726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66727       };
66728     } catch (std::exception& e) {
66729       {
66730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66731       };
66732     } catch (...) {
66733       {
66734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66735       };
66736     }
66737   }
66738 }
66739
66740
66741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
66742   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66743   std::string *arg2 = 0 ;
66744
66745   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66746   if (!jarg2) {
66747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66748     return ;
66749   }
66750   std::string arg2_str(jarg2);
66751   arg2 = &arg2_str;
66752   {
66753     try {
66754       (arg1)->SetImage((std::string const &)*arg2);
66755     } catch (std::out_of_range& e) {
66756       {
66757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66758       };
66759     } catch (std::exception& e) {
66760       {
66761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66762       };
66763     } catch (...) {
66764       {
66765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66766       };
66767     }
66768   }
66769
66770   //argout typemap for const std::string&
66771
66772 }
66773
66774
66775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
66776   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66777   std::string *arg2 = 0 ;
66778   Dali::ImageDimensions arg3 ;
66779   Dali::ImageDimensions *argp3 ;
66780
66781   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66782   if (!jarg2) {
66783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66784     return ;
66785   }
66786   std::string arg2_str(jarg2);
66787   arg2 = &arg2_str;
66788   argp3 = (Dali::ImageDimensions *)jarg3;
66789   if (!argp3) {
66790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
66791     return ;
66792   }
66793   arg3 = *argp3;
66794   {
66795     try {
66796       (arg1)->SetImage((std::string const &)*arg2,arg3);
66797     } catch (std::out_of_range& e) {
66798       {
66799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66800       };
66801     } catch (std::exception& e) {
66802       {
66803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66804       };
66805     } catch (...) {
66806       {
66807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66808       };
66809     }
66810   }
66811
66812   //argout typemap for const std::string&
66813
66814 }
66815
66816
66817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
66818   void * jresult ;
66819   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66820   Dali::Image result;
66821
66822   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66823   {
66824     try {
66825       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
66826     } catch (std::out_of_range& e) {
66827       {
66828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66829       };
66830     } catch (std::exception& e) {
66831       {
66832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66833       };
66834     } catch (...) {
66835       {
66836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66837       };
66838     }
66839   }
66840   jresult = new Dali::Image((const Dali::Image &)result);
66841   return jresult;
66842 }
66843
66844
66845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
66846   int jresult ;
66847   int result;
66848
66849   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
66850   jresult = (int)result;
66851   return jresult;
66852 }
66853
66854
66855 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
66856   int jresult ;
66857   int result;
66858
66859   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
66860   jresult = (int)result;
66861   return jresult;
66862 }
66863
66864
66865 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
66866   int jresult ;
66867   int result;
66868
66869   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
66870   jresult = (int)result;
66871   return jresult;
66872 }
66873
66874
66875 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
66876   int jresult ;
66877   int result;
66878
66879   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
66880   jresult = (int)result;
66881   return jresult;
66882 }
66883
66884
66885 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
66886   int jresult ;
66887   int result;
66888
66889   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
66890   jresult = (int)result;
66891   return jresult;
66892 }
66893
66894
66895 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
66896   int jresult ;
66897   int result;
66898
66899   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
66900   jresult = (int)result;
66901   return jresult;
66902 }
66903
66904
66905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
66906   int jresult ;
66907   int result;
66908
66909   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
66910   jresult = (int)result;
66911   return jresult;
66912 }
66913
66914
66915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
66916   int jresult ;
66917   int result;
66918
66919   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
66920   jresult = (int)result;
66921   return jresult;
66922 }
66923
66924
66925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
66926   void * jresult ;
66927   Dali::Toolkit::Model3dView::Property *result = 0 ;
66928
66929   {
66930     try {
66931       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
66932     } catch (std::out_of_range& e) {
66933       {
66934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66935       };
66936     } catch (std::exception& e) {
66937       {
66938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66939       };
66940     } catch (...) {
66941       {
66942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66943       };
66944     }
66945   }
66946   jresult = (void *)result;
66947   return jresult;
66948 }
66949
66950
66951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
66952   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
66953
66954   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
66955   {
66956     try {
66957       delete arg1;
66958     } catch (std::out_of_range& e) {
66959       {
66960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66961       };
66962     } catch (std::exception& e) {
66963       {
66964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66965       };
66966     } catch (...) {
66967       {
66968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66969       };
66970     }
66971   }
66972 }
66973
66974
66975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
66976   void * jresult ;
66977   Dali::Toolkit::Model3dView result;
66978
66979   {
66980     try {
66981       result = Dali::Toolkit::Model3dView::New();
66982     } catch (std::out_of_range& e) {
66983       {
66984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66985       };
66986     } catch (std::exception& e) {
66987       {
66988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66989       };
66990     } catch (...) {
66991       {
66992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66993       };
66994     }
66995   }
66996   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
66997   return jresult;
66998 }
66999
67000
67001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
67002   void * jresult ;
67003   std::string *arg1 = 0 ;
67004   std::string *arg2 = 0 ;
67005   std::string *arg3 = 0 ;
67006   Dali::Toolkit::Model3dView result;
67007
67008   if (!jarg1) {
67009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67010     return 0;
67011   }
67012   std::string arg1_str(jarg1);
67013   arg1 = &arg1_str;
67014   if (!jarg2) {
67015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67016     return 0;
67017   }
67018   std::string arg2_str(jarg2);
67019   arg2 = &arg2_str;
67020   if (!jarg3) {
67021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67022     return 0;
67023   }
67024   std::string arg3_str(jarg3);
67025   arg3 = &arg3_str;
67026   {
67027     try {
67028       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
67029     } catch (std::out_of_range& e) {
67030       {
67031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67032       };
67033     } catch (std::exception& e) {
67034       {
67035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67036       };
67037     } catch (...) {
67038       {
67039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67040       };
67041     }
67042   }
67043   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67044
67045   //argout typemap for const std::string&
67046
67047
67048   //argout typemap for const std::string&
67049
67050
67051   //argout typemap for const std::string&
67052
67053   return jresult;
67054 }
67055
67056
67057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
67058   void * jresult ;
67059   Dali::Toolkit::Model3dView *result = 0 ;
67060
67061   {
67062     try {
67063       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
67064     } catch (std::out_of_range& e) {
67065       {
67066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67067       };
67068     } catch (std::exception& e) {
67069       {
67070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67071       };
67072     } catch (...) {
67073       {
67074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67075       };
67076     }
67077   }
67078   jresult = (void *)result;
67079   return jresult;
67080 }
67081
67082
67083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
67084   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67085
67086   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67087   {
67088     try {
67089       delete arg1;
67090     } catch (std::out_of_range& e) {
67091       {
67092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67093       };
67094     } catch (std::exception& e) {
67095       {
67096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67097       };
67098     } catch (...) {
67099       {
67100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67101       };
67102     }
67103   }
67104 }
67105
67106
67107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
67108   void * jresult ;
67109   Dali::Toolkit::Model3dView *arg1 = 0 ;
67110   Dali::Toolkit::Model3dView *result = 0 ;
67111
67112   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67113   if (!arg1) {
67114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67115     return 0;
67116   }
67117   {
67118     try {
67119       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
67120     } catch (std::out_of_range& e) {
67121       {
67122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67123       };
67124     } catch (std::exception& e) {
67125       {
67126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67127       };
67128     } catch (...) {
67129       {
67130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67131       };
67132     }
67133   }
67134   jresult = (void *)result;
67135   return jresult;
67136 }
67137
67138
67139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
67140   void * jresult ;
67141   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67142   Dali::Toolkit::Model3dView *arg2 = 0 ;
67143   Dali::Toolkit::Model3dView *result = 0 ;
67144
67145   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67146   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
67147   if (!arg2) {
67148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67149     return 0;
67150   }
67151   {
67152     try {
67153       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
67154     } catch (std::out_of_range& e) {
67155       {
67156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67157       };
67158     } catch (std::exception& e) {
67159       {
67160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67161       };
67162     } catch (...) {
67163       {
67164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67165       };
67166     }
67167   }
67168   jresult = (void *)result;
67169   return jresult;
67170 }
67171
67172
67173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
67174   void * jresult ;
67175   Dali::BaseHandle arg1 ;
67176   Dali::BaseHandle *argp1 ;
67177   Dali::Toolkit::Model3dView result;
67178
67179   argp1 = (Dali::BaseHandle *)jarg1;
67180   if (!argp1) {
67181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67182     return 0;
67183   }
67184   arg1 = *argp1;
67185   {
67186     try {
67187       result = Dali::Toolkit::Model3dView::DownCast(arg1);
67188     } catch (std::out_of_range& e) {
67189       {
67190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67191       };
67192     } catch (std::exception& e) {
67193       {
67194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67195       };
67196     } catch (...) {
67197       {
67198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67199       };
67200     }
67201   }
67202   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67203   return jresult;
67204 }
67205
67206
67207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
67208   int jresult ;
67209   int result;
67210
67211   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
67212   jresult = (int)result;
67213   return jresult;
67214 }
67215
67216
67217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
67218   int jresult ;
67219   int result;
67220
67221   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
67222   jresult = (int)result;
67223   return jresult;
67224 }
67225
67226
67227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
67228   int jresult ;
67229   int result;
67230
67231   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
67232   jresult = (int)result;
67233   return jresult;
67234 }
67235
67236
67237 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
67238   int jresult ;
67239   int result;
67240
67241   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
67242   jresult = (int)result;
67243   return jresult;
67244 }
67245
67246
67247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
67248   int jresult ;
67249   int result;
67250
67251   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
67252   jresult = (int)result;
67253   return jresult;
67254 }
67255
67256
67257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
67258   int jresult ;
67259   int result;
67260
67261   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
67262   jresult = (int)result;
67263   return jresult;
67264 }
67265
67266
67267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
67268   int jresult ;
67269   int result;
67270
67271   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
67272   jresult = (int)result;
67273   return jresult;
67274 }
67275
67276
67277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
67278   int jresult ;
67279   int result;
67280
67281   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
67282   jresult = (int)result;
67283   return jresult;
67284 }
67285
67286
67287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
67288   int jresult ;
67289   int result;
67290
67291   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
67292   jresult = (int)result;
67293   return jresult;
67294 }
67295
67296
67297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
67298   void * jresult ;
67299   Dali::Toolkit::ScrollBar::Property *result = 0 ;
67300
67301   {
67302     try {
67303       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
67304     } catch (std::out_of_range& e) {
67305       {
67306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67307       };
67308     } catch (std::exception& e) {
67309       {
67310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67311       };
67312     } catch (...) {
67313       {
67314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67315       };
67316     }
67317   }
67318   jresult = (void *)result;
67319   return jresult;
67320 }
67321
67322
67323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
67324   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
67325
67326   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
67327   {
67328     try {
67329       delete arg1;
67330     } catch (std::out_of_range& e) {
67331       {
67332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67333       };
67334     } catch (std::exception& e) {
67335       {
67336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67337       };
67338     } catch (...) {
67339       {
67340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67341       };
67342     }
67343   }
67344 }
67345
67346
67347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
67348   void * jresult ;
67349   Dali::Toolkit::ScrollBar *result = 0 ;
67350
67351   {
67352     try {
67353       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
67354     } catch (std::out_of_range& e) {
67355       {
67356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67357       };
67358     } catch (std::exception& e) {
67359       {
67360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67361       };
67362     } catch (...) {
67363       {
67364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67365       };
67366     }
67367   }
67368   jresult = (void *)result;
67369   return jresult;
67370 }
67371
67372
67373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
67374   void * jresult ;
67375   Dali::Toolkit::ScrollBar *arg1 = 0 ;
67376   Dali::Toolkit::ScrollBar *result = 0 ;
67377
67378   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67379   if (!arg1) {
67380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67381     return 0;
67382   }
67383   {
67384     try {
67385       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
67386     } catch (std::out_of_range& e) {
67387       {
67388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67389       };
67390     } catch (std::exception& e) {
67391       {
67392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67393       };
67394     } catch (...) {
67395       {
67396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67397       };
67398     }
67399   }
67400   jresult = (void *)result;
67401   return jresult;
67402 }
67403
67404
67405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
67406   void * jresult ;
67407   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67408   Dali::Toolkit::ScrollBar *arg2 = 0 ;
67409   Dali::Toolkit::ScrollBar *result = 0 ;
67410
67411   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67412   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
67413   if (!arg2) {
67414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67415     return 0;
67416   }
67417   {
67418     try {
67419       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
67420     } catch (std::out_of_range& e) {
67421       {
67422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67423       };
67424     } catch (std::exception& e) {
67425       {
67426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67427       };
67428     } catch (...) {
67429       {
67430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67431       };
67432     }
67433   }
67434   jresult = (void *)result;
67435   return jresult;
67436 }
67437
67438
67439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
67440   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67441
67442   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67443   {
67444     try {
67445       delete arg1;
67446     } catch (std::out_of_range& e) {
67447       {
67448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67449       };
67450     } catch (std::exception& e) {
67451       {
67452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67453       };
67454     } catch (...) {
67455       {
67456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67457       };
67458     }
67459   }
67460 }
67461
67462
67463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
67464   void * jresult ;
67465   Dali::Toolkit::ScrollBar::Direction arg1 ;
67466   Dali::Toolkit::ScrollBar result;
67467
67468   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
67469   {
67470     try {
67471       result = Dali::Toolkit::ScrollBar::New(arg1);
67472     } catch (std::out_of_range& e) {
67473       {
67474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67475       };
67476     } catch (std::exception& e) {
67477       {
67478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67479       };
67480     } catch (...) {
67481       {
67482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67483       };
67484     }
67485   }
67486   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67487   return jresult;
67488 }
67489
67490
67491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
67492   void * jresult ;
67493   Dali::Toolkit::ScrollBar result;
67494
67495   {
67496     try {
67497       result = Dali::Toolkit::ScrollBar::New();
67498     } catch (std::out_of_range& e) {
67499       {
67500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67501       };
67502     } catch (std::exception& e) {
67503       {
67504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67505       };
67506     } catch (...) {
67507       {
67508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67509       };
67510     }
67511   }
67512   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67513   return jresult;
67514 }
67515
67516
67517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
67518   void * jresult ;
67519   Dali::BaseHandle arg1 ;
67520   Dali::BaseHandle *argp1 ;
67521   Dali::Toolkit::ScrollBar result;
67522
67523   argp1 = (Dali::BaseHandle *)jarg1;
67524   if (!argp1) {
67525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67526     return 0;
67527   }
67528   arg1 = *argp1;
67529   {
67530     try {
67531       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
67532     } catch (std::out_of_range& e) {
67533       {
67534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67535       };
67536     } catch (std::exception& e) {
67537       {
67538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67539       };
67540     } catch (...) {
67541       {
67542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67543       };
67544     }
67545   }
67546   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67547   return jresult;
67548 }
67549
67550
67551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
67552   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67553   Dali::Handle arg2 ;
67554   Dali::Property::Index arg3 ;
67555   Dali::Property::Index arg4 ;
67556   Dali::Property::Index arg5 ;
67557   Dali::Property::Index arg6 ;
67558   Dali::Handle *argp2 ;
67559
67560   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67561   argp2 = (Dali::Handle *)jarg2;
67562   if (!argp2) {
67563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
67564     return ;
67565   }
67566   arg2 = *argp2;
67567   arg3 = (Dali::Property::Index)jarg3;
67568   arg4 = (Dali::Property::Index)jarg4;
67569   arg5 = (Dali::Property::Index)jarg5;
67570   arg6 = (Dali::Property::Index)jarg6;
67571   {
67572     try {
67573       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
67574     } catch (std::out_of_range& e) {
67575       {
67576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67577       };
67578     } catch (std::exception& e) {
67579       {
67580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67581       };
67582     } catch (...) {
67583       {
67584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67585       };
67586     }
67587   }
67588 }
67589
67590
67591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
67592   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67593   Dali::Actor arg2 ;
67594   Dali::Actor *argp2 ;
67595
67596   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67597   argp2 = (Dali::Actor *)jarg2;
67598   if (!argp2) {
67599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
67600     return ;
67601   }
67602   arg2 = *argp2;
67603   {
67604     try {
67605       (arg1)->SetScrollIndicator(arg2);
67606     } catch (std::out_of_range& e) {
67607       {
67608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67609       };
67610     } catch (std::exception& e) {
67611       {
67612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67613       };
67614     } catch (...) {
67615       {
67616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67617       };
67618     }
67619   }
67620 }
67621
67622
67623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
67624   void * jresult ;
67625   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67626   Dali::Actor result;
67627
67628   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67629   {
67630     try {
67631       result = (arg1)->GetScrollIndicator();
67632     } catch (std::out_of_range& e) {
67633       {
67634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67635       };
67636     } catch (std::exception& e) {
67637       {
67638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67639       };
67640     } catch (...) {
67641       {
67642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67643       };
67644     }
67645   }
67646   jresult = new Dali::Actor((const Dali::Actor &)result);
67647   return jresult;
67648 }
67649
67650
67651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
67652   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67653   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
67654
67655   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67656   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
67657   if (!arg2) {
67658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
67659     return ;
67660   }
67661   {
67662     try {
67663       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
67664     } catch (std::out_of_range& e) {
67665       {
67666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67667       };
67668     } catch (std::exception& e) {
67669       {
67670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67671       };
67672     } catch (...) {
67673       {
67674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67675       };
67676     }
67677   }
67678 }
67679
67680
67681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
67682   void * jresult ;
67683   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67684   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > result;
67685
67686   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67687   {
67688     try {
67689       result = ((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollPositionIntervals();
67690     } catch (std::out_of_range& e) {
67691       {
67692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67693       };
67694     } catch (std::exception& e) {
67695       {
67696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67697       };
67698     } catch (...) {
67699       {
67700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67701       };
67702     }
67703   }
67704   jresult = new Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true >((const Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > &)result);
67705   return jresult;
67706 }
67707
67708
67709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
67710   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67711   Dali::Toolkit::ScrollBar::Direction arg2 ;
67712
67713   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67714   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
67715   {
67716     try {
67717       (arg1)->SetScrollDirection(arg2);
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 int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
67736   int jresult ;
67737   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67738   Dali::Toolkit::ScrollBar::Direction result;
67739
67740   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67741   {
67742     try {
67743       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
67744     } catch (std::out_of_range& e) {
67745       {
67746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67747       };
67748     } catch (std::exception& e) {
67749       {
67750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67751       };
67752     } catch (...) {
67753       {
67754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67755       };
67756     }
67757   }
67758   jresult = (int)result;
67759   return jresult;
67760 }
67761
67762
67763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
67764   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67765   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
67766
67767   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67768   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
67769   {
67770     try {
67771       (arg1)->SetIndicatorHeightPolicy(arg2);
67772     } catch (std::out_of_range& e) {
67773       {
67774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67775       };
67776     } catch (std::exception& e) {
67777       {
67778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67779       };
67780     } catch (...) {
67781       {
67782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67783       };
67784     }
67785   }
67786 }
67787
67788
67789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
67790   int jresult ;
67791   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67792   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
67793
67794   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67795   {
67796     try {
67797       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
67798     } catch (std::out_of_range& e) {
67799       {
67800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67801       };
67802     } catch (std::exception& e) {
67803       {
67804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67805       };
67806     } catch (...) {
67807       {
67808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67809       };
67810     }
67811   }
67812   jresult = (int)result;
67813   return jresult;
67814 }
67815
67816
67817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
67818   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67819   float arg2 ;
67820
67821   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67822   arg2 = (float)jarg2;
67823   {
67824     try {
67825       (arg1)->SetIndicatorFixedHeight(arg2);
67826     } catch (std::out_of_range& e) {
67827       {
67828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67829       };
67830     } catch (std::exception& e) {
67831       {
67832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67833       };
67834     } catch (...) {
67835       {
67836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67837       };
67838     }
67839   }
67840 }
67841
67842
67843 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
67844   float jresult ;
67845   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67846   float result;
67847
67848   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67849   {
67850     try {
67851       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
67852     } catch (std::out_of_range& e) {
67853       {
67854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67855       };
67856     } catch (std::exception& e) {
67857       {
67858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67859       };
67860     } catch (...) {
67861       {
67862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67863       };
67864     }
67865   }
67866   jresult = result;
67867   return jresult;
67868 }
67869
67870
67871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
67872   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67873   float arg2 ;
67874
67875   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67876   arg2 = (float)jarg2;
67877   {
67878     try {
67879       (arg1)->SetIndicatorShowDuration(arg2);
67880     } catch (std::out_of_range& e) {
67881       {
67882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67883       };
67884     } catch (std::exception& e) {
67885       {
67886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67887       };
67888     } catch (...) {
67889       {
67890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67891       };
67892     }
67893   }
67894 }
67895
67896
67897 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
67898   float jresult ;
67899   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67900   float result;
67901
67902   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67903   {
67904     try {
67905       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
67906     } catch (std::out_of_range& e) {
67907       {
67908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67909       };
67910     } catch (std::exception& e) {
67911       {
67912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67913       };
67914     } catch (...) {
67915       {
67916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67917       };
67918     }
67919   }
67920   jresult = result;
67921   return jresult;
67922 }
67923
67924
67925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
67926   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67927   float arg2 ;
67928
67929   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67930   arg2 = (float)jarg2;
67931   {
67932     try {
67933       (arg1)->SetIndicatorHideDuration(arg2);
67934     } catch (std::out_of_range& e) {
67935       {
67936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67937       };
67938     } catch (std::exception& e) {
67939       {
67940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67941       };
67942     } catch (...) {
67943       {
67944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67945       };
67946     }
67947   }
67948 }
67949
67950
67951 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
67952   float jresult ;
67953   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67954   float result;
67955
67956   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67957   {
67958     try {
67959       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
67960     } catch (std::out_of_range& e) {
67961       {
67962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67963       };
67964     } catch (std::exception& e) {
67965       {
67966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67967       };
67968     } catch (...) {
67969       {
67970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67971       };
67972     }
67973   }
67974   jresult = result;
67975   return jresult;
67976 }
67977
67978
67979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
67980   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67981
67982   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67983   {
67984     try {
67985       (arg1)->ShowIndicator();
67986     } catch (std::out_of_range& e) {
67987       {
67988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67989       };
67990     } catch (std::exception& e) {
67991       {
67992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67993       };
67994     } catch (...) {
67995       {
67996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67997       };
67998     }
67999   }
68000 }
68001
68002
68003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
68004   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68005
68006   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68007   {
68008     try {
68009       (arg1)->HideIndicator();
68010     } catch (std::out_of_range& e) {
68011       {
68012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68013       };
68014     } catch (std::exception& e) {
68015       {
68016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68017       };
68018     } catch (...) {
68019       {
68020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68021       };
68022     }
68023   }
68024 }
68025
68026
68027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
68028   void * jresult ;
68029   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68030   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
68031
68032   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68033   {
68034     try {
68035       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
68036     } catch (std::out_of_range& e) {
68037       {
68038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68039       };
68040     } catch (std::exception& e) {
68041       {
68042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68043       };
68044     } catch (...) {
68045       {
68046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68047       };
68048     }
68049   }
68050   jresult = (void *)result;
68051   return jresult;
68052 }
68053
68054
68055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
68056   void * jresult ;
68057   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68058   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
68059
68060   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68061   {
68062     try {
68063       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
68064     } catch (std::out_of_range& e) {
68065       {
68066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68067       };
68068     } catch (std::exception& e) {
68069       {
68070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68071       };
68072     } catch (...) {
68073       {
68074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68075       };
68076     }
68077   }
68078   jresult = (void *)result;
68079   return jresult;
68080 }
68081
68082
68083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
68084   int jresult ;
68085   int result;
68086
68087   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
68088   jresult = (int)result;
68089   return jresult;
68090 }
68091
68092
68093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
68094   int jresult ;
68095   int result;
68096
68097   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
68098   jresult = (int)result;
68099   return jresult;
68100 }
68101
68102
68103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
68104   int jresult ;
68105   int result;
68106
68107   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
68108   jresult = (int)result;
68109   return jresult;
68110 }
68111
68112
68113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
68114   int jresult ;
68115   int result;
68116
68117   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
68118   jresult = (int)result;
68119   return jresult;
68120 }
68121
68122
68123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
68124   int jresult ;
68125   int result;
68126
68127   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
68128   jresult = (int)result;
68129   return jresult;
68130 }
68131
68132
68133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
68134   int jresult ;
68135   int result;
68136
68137   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
68138   jresult = (int)result;
68139   return jresult;
68140 }
68141
68142
68143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
68144   int jresult ;
68145   int result;
68146
68147   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
68148   jresult = (int)result;
68149   return jresult;
68150 }
68151
68152
68153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
68154   int jresult ;
68155   int result;
68156
68157   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
68158   jresult = (int)result;
68159   return jresult;
68160 }
68161
68162
68163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
68164   int jresult ;
68165   int result;
68166
68167   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
68168   jresult = (int)result;
68169   return jresult;
68170 }
68171
68172
68173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
68174   int jresult ;
68175   int result;
68176
68177   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
68178   jresult = (int)result;
68179   return jresult;
68180 }
68181
68182
68183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
68184   int jresult ;
68185   int result;
68186
68187   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
68188   jresult = (int)result;
68189   return jresult;
68190 }
68191
68192
68193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
68194   int jresult ;
68195   int result;
68196
68197   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
68198   jresult = (int)result;
68199   return jresult;
68200 }
68201
68202
68203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
68204   int jresult ;
68205   int result;
68206
68207   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
68208   jresult = (int)result;
68209   return jresult;
68210 }
68211
68212
68213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
68214   int jresult ;
68215   int result;
68216
68217   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
68218   jresult = (int)result;
68219   return jresult;
68220 }
68221
68222
68223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
68224   void * jresult ;
68225   Dali::Toolkit::Scrollable::Property *result = 0 ;
68226
68227   {
68228     try {
68229       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
68230     } catch (std::out_of_range& e) {
68231       {
68232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68233       };
68234     } catch (std::exception& e) {
68235       {
68236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68237       };
68238     } catch (...) {
68239       {
68240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68241       };
68242     }
68243   }
68244   jresult = (void *)result;
68245   return jresult;
68246 }
68247
68248
68249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
68250   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
68251
68252   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
68253   {
68254     try {
68255       delete arg1;
68256     } catch (std::out_of_range& e) {
68257       {
68258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68259       };
68260     } catch (std::exception& e) {
68261       {
68262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68263       };
68264     } catch (...) {
68265       {
68266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68267       };
68268     }
68269   }
68270 }
68271
68272
68273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
68274   void * jresult ;
68275   Dali::Toolkit::Scrollable *result = 0 ;
68276
68277   {
68278     try {
68279       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
68280     } catch (std::out_of_range& e) {
68281       {
68282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68283       };
68284     } catch (std::exception& e) {
68285       {
68286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68287       };
68288     } catch (...) {
68289       {
68290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68291       };
68292     }
68293   }
68294   jresult = (void *)result;
68295   return jresult;
68296 }
68297
68298
68299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
68300   void * jresult ;
68301   Dali::Toolkit::Scrollable *arg1 = 0 ;
68302   Dali::Toolkit::Scrollable *result = 0 ;
68303
68304   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68305   if (!arg1) {
68306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68307     return 0;
68308   }
68309   {
68310     try {
68311       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
68312     } catch (std::out_of_range& e) {
68313       {
68314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68315       };
68316     } catch (std::exception& e) {
68317       {
68318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68319       };
68320     } catch (...) {
68321       {
68322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68323       };
68324     }
68325   }
68326   jresult = (void *)result;
68327   return jresult;
68328 }
68329
68330
68331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
68332   void * jresult ;
68333   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68334   Dali::Toolkit::Scrollable *arg2 = 0 ;
68335   Dali::Toolkit::Scrollable *result = 0 ;
68336
68337   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68338   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
68339   if (!arg2) {
68340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68341     return 0;
68342   }
68343   {
68344     try {
68345       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
68346     } catch (std::out_of_range& e) {
68347       {
68348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68349       };
68350     } catch (std::exception& e) {
68351       {
68352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68353       };
68354     } catch (...) {
68355       {
68356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68357       };
68358     }
68359   }
68360   jresult = (void *)result;
68361   return jresult;
68362 }
68363
68364
68365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
68366   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68367
68368   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68369   {
68370     try {
68371       delete arg1;
68372     } catch (std::out_of_range& e) {
68373       {
68374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68375       };
68376     } catch (std::exception& e) {
68377       {
68378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68379       };
68380     } catch (...) {
68381       {
68382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68383       };
68384     }
68385   }
68386 }
68387
68388
68389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
68390   void * jresult ;
68391   Dali::BaseHandle arg1 ;
68392   Dali::BaseHandle *argp1 ;
68393   Dali::Toolkit::Scrollable result;
68394
68395   argp1 = (Dali::BaseHandle *)jarg1;
68396   if (!argp1) {
68397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68398     return 0;
68399   }
68400   arg1 = *argp1;
68401   {
68402     try {
68403       result = Dali::Toolkit::Scrollable::DownCast(arg1);
68404     } catch (std::out_of_range& e) {
68405       {
68406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68407       };
68408     } catch (std::exception& e) {
68409       {
68410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68411       };
68412     } catch (...) {
68413       {
68414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68415       };
68416     }
68417   }
68418   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
68419   return jresult;
68420 }
68421
68422
68423 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
68424   unsigned int jresult ;
68425   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68426   bool result;
68427
68428   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68429   {
68430     try {
68431       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
68432     } catch (std::out_of_range& e) {
68433       {
68434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68435       };
68436     } catch (std::exception& e) {
68437       {
68438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68439       };
68440     } catch (...) {
68441       {
68442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68443       };
68444     }
68445   }
68446   jresult = result;
68447   return jresult;
68448 }
68449
68450
68451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
68452   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68453   bool arg2 ;
68454
68455   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68456   arg2 = jarg2 ? true : false;
68457   {
68458     try {
68459       (arg1)->SetOvershootEnabled(arg2);
68460     } catch (std::out_of_range& e) {
68461       {
68462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68463       };
68464     } catch (std::exception& e) {
68465       {
68466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68467       };
68468     } catch (...) {
68469       {
68470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68471       };
68472     }
68473   }
68474 }
68475
68476
68477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
68478   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68479   Dali::Vector4 *arg2 = 0 ;
68480
68481   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68482   arg2 = (Dali::Vector4 *)jarg2;
68483   if (!arg2) {
68484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
68485     return ;
68486   }
68487   {
68488     try {
68489       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
68490     } catch (std::out_of_range& e) {
68491       {
68492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68493       };
68494     } catch (std::exception& e) {
68495       {
68496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68497       };
68498     } catch (...) {
68499       {
68500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68501       };
68502     }
68503   }
68504 }
68505
68506
68507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
68508   void * jresult ;
68509   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68510   Dali::Vector4 result;
68511
68512   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68513   {
68514     try {
68515       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
68516     } catch (std::out_of_range& e) {
68517       {
68518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68519       };
68520     } catch (std::exception& e) {
68521       {
68522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68523       };
68524     } catch (...) {
68525       {
68526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68527       };
68528     }
68529   }
68530   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
68531   return jresult;
68532 }
68533
68534
68535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
68536   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68537   float arg2 ;
68538
68539   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68540   arg2 = (float)jarg2;
68541   {
68542     try {
68543       (arg1)->SetOvershootAnimationSpeed(arg2);
68544     } catch (std::out_of_range& e) {
68545       {
68546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68547       };
68548     } catch (std::exception& e) {
68549       {
68550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68551       };
68552     } catch (...) {
68553       {
68554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68555       };
68556     }
68557   }
68558 }
68559
68560
68561 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
68562   float jresult ;
68563   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68564   float result;
68565
68566   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68567   {
68568     try {
68569       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
68570     } catch (std::out_of_range& e) {
68571       {
68572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68573       };
68574     } catch (std::exception& e) {
68575       {
68576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68577       };
68578     } catch (...) {
68579       {
68580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68581       };
68582     }
68583   }
68584   jresult = result;
68585   return jresult;
68586 }
68587
68588
68589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
68590   void * jresult ;
68591   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68592   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
68593
68594   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68595   {
68596     try {
68597       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
68598     } catch (std::out_of_range& e) {
68599       {
68600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68601       };
68602     } catch (std::exception& e) {
68603       {
68604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68605       };
68606     } catch (...) {
68607       {
68608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68609       };
68610     }
68611   }
68612   jresult = (void *)result;
68613   return jresult;
68614 }
68615
68616
68617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
68618   void * jresult ;
68619   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68620   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
68621
68622   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68623   {
68624     try {
68625       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
68626     } catch (std::out_of_range& e) {
68627       {
68628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68629       };
68630     } catch (std::exception& e) {
68631       {
68632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68633       };
68634     } catch (...) {
68635       {
68636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68637       };
68638     }
68639   }
68640   jresult = (void *)result;
68641   return jresult;
68642 }
68643
68644
68645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
68646   void * jresult ;
68647   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68648   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
68649
68650   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68651   {
68652     try {
68653       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
68654     } catch (std::out_of_range& e) {
68655       {
68656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68657       };
68658     } catch (std::exception& e) {
68659       {
68660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68661       };
68662     } catch (...) {
68663       {
68664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68665       };
68666     }
68667   }
68668   jresult = (void *)result;
68669   return jresult;
68670 }
68671
68672
68673 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
68674   unsigned int jresult ;
68675   Dali::Toolkit::ControlOrientation::Type arg1 ;
68676   bool result;
68677
68678   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
68679   {
68680     try {
68681       result = (bool)Dali::Toolkit::IsVertical(arg1);
68682     } catch (std::out_of_range& e) {
68683       {
68684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68685       };
68686     } catch (std::exception& e) {
68687       {
68688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68689       };
68690     } catch (...) {
68691       {
68692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68693       };
68694     }
68695   }
68696   jresult = result;
68697   return jresult;
68698 }
68699
68700
68701 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
68702   unsigned int jresult ;
68703   Dali::Toolkit::ControlOrientation::Type arg1 ;
68704   bool result;
68705
68706   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
68707   {
68708     try {
68709       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
68710     } catch (std::out_of_range& e) {
68711       {
68712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68713       };
68714     } catch (std::exception& e) {
68715       {
68716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68717       };
68718     } catch (...) {
68719       {
68720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68721       };
68722     }
68723   }
68724   jresult = result;
68725   return jresult;
68726 }
68727
68728
68729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
68730   void * jresult ;
68731   unsigned int arg1 ;
68732   unsigned int arg2 ;
68733   Dali::Toolkit::ItemRange *result = 0 ;
68734
68735   arg1 = (unsigned int)jarg1;
68736   arg2 = (unsigned int)jarg2;
68737   {
68738     try {
68739       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
68740     } catch (std::out_of_range& e) {
68741       {
68742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68743       };
68744     } catch (std::exception& e) {
68745       {
68746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68747       };
68748     } catch (...) {
68749       {
68750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68751       };
68752     }
68753   }
68754   jresult = (void *)result;
68755   return jresult;
68756 }
68757
68758
68759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
68760   void * jresult ;
68761   Dali::Toolkit::ItemRange *arg1 = 0 ;
68762   Dali::Toolkit::ItemRange *result = 0 ;
68763
68764   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68765   if (!arg1) {
68766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
68767     return 0;
68768   }
68769   {
68770     try {
68771       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
68772     } catch (std::out_of_range& e) {
68773       {
68774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68775       };
68776     } catch (std::exception& e) {
68777       {
68778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68779       };
68780     } catch (...) {
68781       {
68782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68783       };
68784     }
68785   }
68786   jresult = (void *)result;
68787   return jresult;
68788 }
68789
68790
68791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
68792   void * jresult ;
68793   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68794   Dali::Toolkit::ItemRange *arg2 = 0 ;
68795   Dali::Toolkit::ItemRange *result = 0 ;
68796
68797   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68798   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
68799   if (!arg2) {
68800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
68801     return 0;
68802   }
68803   {
68804     try {
68805       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
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 = (void *)result;
68821   return jresult;
68822 }
68823
68824
68825 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
68826   unsigned int jresult ;
68827   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68828   unsigned int arg2 ;
68829   bool result;
68830
68831   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68832   arg2 = (unsigned int)jarg2;
68833   {
68834     try {
68835       result = (bool)(arg1)->Within(arg2);
68836     } catch (std::out_of_range& e) {
68837       {
68838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68839       };
68840     } catch (std::exception& e) {
68841       {
68842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68843       };
68844     } catch (...) {
68845       {
68846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68847       };
68848     }
68849   }
68850   jresult = result;
68851   return jresult;
68852 }
68853
68854
68855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
68856   void * jresult ;
68857   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68858   Dali::Toolkit::ItemRange *arg2 = 0 ;
68859   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
68860
68861   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68862   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
68863   if (!arg2) {
68864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
68865     return 0;
68866   }
68867   {
68868     try {
68869       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
68870     } catch (std::out_of_range& e) {
68871       {
68872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68873       };
68874     } catch (std::exception& e) {
68875       {
68876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68877       };
68878     } catch (...) {
68879       {
68880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68881       };
68882     }
68883   }
68884   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
68885   return jresult;
68886 }
68887
68888
68889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
68890   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68891   unsigned int arg2 ;
68892
68893   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68894   arg2 = (unsigned int)jarg2;
68895   if (arg1) (arg1)->begin = arg2;
68896 }
68897
68898
68899 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
68900   unsigned int jresult ;
68901   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68902   unsigned int result;
68903
68904   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68905   result = (unsigned int) ((arg1)->begin);
68906   jresult = result;
68907   return jresult;
68908 }
68909
68910
68911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
68912   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68913   unsigned int arg2 ;
68914
68915   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68916   arg2 = (unsigned int)jarg2;
68917   if (arg1) (arg1)->end = arg2;
68918 }
68919
68920
68921 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
68922   unsigned int jresult ;
68923   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68924   unsigned int result;
68925
68926   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68927   result = (unsigned int) ((arg1)->end);
68928   jresult = result;
68929   return jresult;
68930 }
68931
68932
68933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
68934   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68935
68936   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68937   {
68938     try {
68939       delete arg1;
68940     } catch (std::out_of_range& e) {
68941       {
68942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68943       };
68944     } catch (std::exception& e) {
68945       {
68946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68947       };
68948     } catch (...) {
68949       {
68950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68951       };
68952     }
68953   }
68954 }
68955
68956
68957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
68958   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68959
68960   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68961   {
68962     try {
68963       delete arg1;
68964     } catch (std::out_of_range& e) {
68965       {
68966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68967       };
68968     } catch (std::exception& e) {
68969       {
68970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68971       };
68972     } catch (...) {
68973       {
68974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68975       };
68976     }
68977   }
68978 }
68979
68980
68981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
68982   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68983   Dali::Toolkit::ControlOrientation::Type arg2 ;
68984
68985   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68986   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
68987   {
68988     try {
68989       (arg1)->SetOrientation(arg2);
68990     } catch (std::out_of_range& e) {
68991       {
68992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68993       };
68994     } catch (std::exception& e) {
68995       {
68996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68997       };
68998     } catch (...) {
68999       {
69000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69001       };
69002     }
69003   }
69004 }
69005
69006
69007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
69008   int jresult ;
69009   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69010   Dali::Toolkit::ControlOrientation::Type result;
69011
69012   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69013   {
69014     try {
69015       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
69016     } catch (std::out_of_range& e) {
69017       {
69018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69019       };
69020     } catch (std::exception& e) {
69021       {
69022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69023       };
69024     } catch (...) {
69025       {
69026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69027       };
69028     }
69029   }
69030   jresult = (int)result;
69031   return jresult;
69032 }
69033
69034
69035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
69036   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69037   Dali::Property::Map *arg2 = 0 ;
69038
69039   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69040   arg2 = (Dali::Property::Map *)jarg2;
69041   if (!arg2) {
69042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
69043     return ;
69044   }
69045   {
69046     try {
69047       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
69048     } catch (std::out_of_range& e) {
69049       {
69050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69051       };
69052     } catch (std::exception& e) {
69053       {
69054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69055       };
69056     } catch (...) {
69057       {
69058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69059       };
69060     }
69061   }
69062 }
69063
69064
69065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
69066   void * jresult ;
69067   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69068   Dali::Property::Map result;
69069
69070   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69071   {
69072     try {
69073       result = (arg1)->GetLayoutProperties();
69074     } catch (std::out_of_range& e) {
69075       {
69076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69077       };
69078     } catch (std::exception& e) {
69079       {
69080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69081       };
69082     } catch (...) {
69083       {
69084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69085       };
69086     }
69087   }
69088   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
69089   return jresult;
69090 }
69091
69092
69093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
69094   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69095   unsigned int arg2 ;
69096   Dali::Vector3 *arg3 = 0 ;
69097   Dali::Vector3 *arg4 = 0 ;
69098
69099   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69100   arg2 = (unsigned int)jarg2;
69101   arg3 = (Dali::Vector3 *)jarg3;
69102   if (!arg3) {
69103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69104     return ;
69105   }
69106   arg4 = (Dali::Vector3 *)jarg4;
69107   if (!arg4) {
69108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69109     return ;
69110   }
69111   {
69112     try {
69113       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
69114     } catch (std::out_of_range& e) {
69115       {
69116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69117       };
69118     } catch (std::exception& e) {
69119       {
69120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69121       };
69122     } catch (...) {
69123       {
69124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69125       };
69126     }
69127   }
69128 }
69129
69130
69131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
69132   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69133   Dali::Vector3 *arg2 = 0 ;
69134
69135   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69136   arg2 = (Dali::Vector3 *)jarg2;
69137   if (!arg2) {
69138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69139     return ;
69140   }
69141   {
69142     try {
69143       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
69144     } catch (std::out_of_range& e) {
69145       {
69146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69147       };
69148     } catch (std::exception& e) {
69149       {
69150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69151       };
69152     } catch (...) {
69153       {
69154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69155       };
69156     }
69157   }
69158 }
69159
69160
69161 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
69162   float jresult ;
69163   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69164   unsigned int arg2 ;
69165   Dali::Vector3 arg3 ;
69166   Dali::Vector3 *argp3 ;
69167   float result;
69168
69169   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69170   arg2 = (unsigned int)jarg2;
69171   argp3 = (Dali::Vector3 *)jarg3;
69172   if (!argp3) {
69173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69174     return 0;
69175   }
69176   arg3 = *argp3;
69177   {
69178     try {
69179       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
69180     } catch (std::out_of_range& e) {
69181       {
69182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69183       };
69184     } catch (std::exception& e) {
69185       {
69186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69187       };
69188     } catch (...) {
69189       {
69190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69191       };
69192     }
69193   }
69194   jresult = result;
69195   return jresult;
69196 }
69197
69198
69199 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
69200   float jresult ;
69201   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69202   float arg2 ;
69203   float result;
69204
69205   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69206   arg2 = (float)jarg2;
69207   {
69208     try {
69209       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
69210     } catch (std::out_of_range& e) {
69211       {
69212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69213       };
69214     } catch (std::exception& e) {
69215       {
69216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69217       };
69218     } catch (...) {
69219       {
69220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69221       };
69222     }
69223   }
69224   jresult = result;
69225   return jresult;
69226 }
69227
69228
69229 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
69230   float jresult ;
69231   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69232   unsigned int arg2 ;
69233   float result;
69234
69235   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69236   arg2 = (unsigned int)jarg2;
69237   {
69238     try {
69239       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
69240     } catch (std::out_of_range& e) {
69241       {
69242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69243       };
69244     } catch (std::exception& e) {
69245       {
69246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69247       };
69248     } catch (...) {
69249       {
69250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69251       };
69252     }
69253   }
69254   jresult = result;
69255   return jresult;
69256 }
69257
69258
69259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
69260   void * jresult ;
69261   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69262   float arg2 ;
69263   Dali::Vector3 arg3 ;
69264   Dali::Vector3 *argp3 ;
69265   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69266
69267   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69268   arg2 = (float)jarg2;
69269   argp3 = (Dali::Vector3 *)jarg3;
69270   if (!argp3) {
69271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69272     return 0;
69273   }
69274   arg3 = *argp3;
69275   {
69276     try {
69277       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
69278     } catch (std::out_of_range& e) {
69279       {
69280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69281       };
69282     } catch (std::exception& e) {
69283       {
69284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69285       };
69286     } catch (...) {
69287       {
69288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69289       };
69290     }
69291   }
69292   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69293   return jresult;
69294 }
69295
69296
69297 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
69298   float jresult ;
69299   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69300   int arg2 ;
69301   float arg3 ;
69302   Dali::Vector3 *arg4 = 0 ;
69303   float result;
69304
69305   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69306   arg2 = (int)jarg2;
69307   arg3 = (float)jarg3;
69308   arg4 = (Dali::Vector3 *)jarg4;
69309   if (!arg4) {
69310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69311     return 0;
69312   }
69313   {
69314     try {
69315       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
69316     } catch (std::out_of_range& e) {
69317       {
69318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69319       };
69320     } catch (std::exception& e) {
69321       {
69322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69323       };
69324     } catch (...) {
69325       {
69326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69327       };
69328     }
69329   }
69330   jresult = result;
69331   return jresult;
69332 }
69333
69334
69335 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
69336   unsigned int jresult ;
69337   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69338   Dali::Vector3 arg2 ;
69339   Dali::Vector3 *argp2 ;
69340   unsigned int result;
69341
69342   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69343   argp2 = (Dali::Vector3 *)jarg2;
69344   if (!argp2) {
69345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69346     return 0;
69347   }
69348   arg2 = *argp2;
69349   {
69350     try {
69351       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
69352     } catch (std::out_of_range& e) {
69353       {
69354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69355       };
69356     } catch (std::exception& e) {
69357       {
69358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69359       };
69360     } catch (...) {
69361       {
69362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69363       };
69364     }
69365   }
69366   jresult = result;
69367   return jresult;
69368 }
69369
69370
69371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
69372   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69373   unsigned int arg2 ;
69374   Dali::Vector3 *arg3 = 0 ;
69375   Dali::Vector3 *arg4 = 0 ;
69376
69377   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69378   arg2 = (unsigned int)jarg2;
69379   arg3 = (Dali::Vector3 *)jarg3;
69380   if (!arg3) {
69381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69382     return ;
69383   }
69384   arg4 = (Dali::Vector3 *)jarg4;
69385   if (!arg4) {
69386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69387     return ;
69388   }
69389   {
69390     try {
69391       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
69392     } catch (std::out_of_range& e) {
69393       {
69394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69395       };
69396     } catch (std::exception& e) {
69397       {
69398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69399       };
69400     } catch (...) {
69401       {
69402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69403       };
69404     }
69405   }
69406 }
69407
69408
69409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
69410   void * jresult ;
69411   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69412   Dali::Degree result;
69413
69414   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69415   {
69416     try {
69417       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
69418     } catch (std::out_of_range& e) {
69419       {
69420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69421       };
69422     } catch (std::exception& e) {
69423       {
69424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69425       };
69426     } catch (...) {
69427       {
69428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69429       };
69430     }
69431   }
69432   jresult = new Dali::Degree((const Dali::Degree &)result);
69433   return jresult;
69434 }
69435
69436
69437 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
69438   float jresult ;
69439   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69440   float result;
69441
69442   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69443   {
69444     try {
69445       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
69446     } catch (std::out_of_range& e) {
69447       {
69448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69449       };
69450     } catch (std::exception& e) {
69451       {
69452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69453       };
69454     } catch (...) {
69455       {
69456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69457       };
69458     }
69459   }
69460   jresult = result;
69461   return jresult;
69462 }
69463
69464
69465 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
69466   float jresult ;
69467   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69468   float result;
69469
69470   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69471   {
69472     try {
69473       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
69474     } catch (std::out_of_range& e) {
69475       {
69476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69477       };
69478     } catch (std::exception& e) {
69479       {
69480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69481       };
69482     } catch (...) {
69483       {
69484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69485       };
69486     }
69487   }
69488   jresult = result;
69489   return jresult;
69490 }
69491
69492
69493 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
69494   float jresult ;
69495   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69496   float result;
69497
69498   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69499   {
69500     try {
69501       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
69502     } catch (std::out_of_range& e) {
69503       {
69504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69505       };
69506     } catch (std::exception& e) {
69507       {
69508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69509       };
69510     } catch (...) {
69511       {
69512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69513       };
69514     }
69515   }
69516   jresult = result;
69517   return jresult;
69518 }
69519
69520
69521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
69522   int jresult ;
69523   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69524   int arg2 ;
69525   int arg3 ;
69526   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
69527   bool arg5 ;
69528   int result;
69529
69530   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69531   arg2 = (int)jarg2;
69532   arg3 = (int)jarg3;
69533   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
69534   arg5 = jarg5 ? true : false;
69535   {
69536     try {
69537       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
69538     } catch (std::out_of_range& e) {
69539       {
69540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69541       };
69542     } catch (std::exception& e) {
69543       {
69544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69545       };
69546     } catch (...) {
69547       {
69548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69549       };
69550     }
69551   }
69552   jresult = result;
69553   return jresult;
69554 }
69555
69556
69557 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
69558   float jresult ;
69559   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69560   float result;
69561
69562   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69563   {
69564     try {
69565       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
69566     } catch (std::out_of_range& e) {
69567       {
69568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69569       };
69570     } catch (std::exception& e) {
69571       {
69572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69573       };
69574     } catch (...) {
69575       {
69576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69577       };
69578     }
69579   }
69580   jresult = result;
69581   return jresult;
69582 }
69583
69584
69585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
69586   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69587   Dali::Actor *arg2 = 0 ;
69588   int arg3 ;
69589   Dali::Vector3 *arg4 = 0 ;
69590   Dali::Actor *arg5 = 0 ;
69591
69592   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69593   arg2 = (Dali::Actor *)jarg2;
69594   if (!arg2) {
69595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
69596     return ;
69597   }
69598   arg3 = (int)jarg3;
69599   arg4 = (Dali::Vector3 *)jarg4;
69600   if (!arg4) {
69601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69602     return ;
69603   }
69604   arg5 = (Dali::Actor *)jarg5;
69605   if (!arg5) {
69606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
69607     return ;
69608   }
69609   {
69610     try {
69611       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
69612     } catch (std::out_of_range& e) {
69613       {
69614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69615       };
69616     } catch (std::exception& e) {
69617       {
69618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69619       };
69620     } catch (...) {
69621       {
69622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69623       };
69624     }
69625   }
69626 }
69627
69628
69629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
69630   void * jresult ;
69631   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69632   int arg2 ;
69633   float arg3 ;
69634   Dali::Vector3 *arg4 = 0 ;
69635   Dali::Vector3 result;
69636
69637   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69638   arg2 = (int)jarg2;
69639   arg3 = (float)jarg3;
69640   arg4 = (Dali::Vector3 *)jarg4;
69641   if (!arg4) {
69642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69643     return 0;
69644   }
69645   {
69646     try {
69647       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
69648     } catch (std::out_of_range& e) {
69649       {
69650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69651       };
69652     } catch (std::exception& e) {
69653       {
69654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69655       };
69656     } catch (...) {
69657       {
69658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69659       };
69660     }
69661   }
69662   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
69663   return jresult;
69664 }
69665
69666
69667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
69668   void * jresult ;
69669   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
69670   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
69671
69672   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
69673   {
69674     try {
69675       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
69676     } catch (std::out_of_range& e) {
69677       {
69678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69679       };
69680     } catch (std::exception& e) {
69681       {
69682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69683       };
69684     } catch (...) {
69685       {
69686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69687       };
69688     }
69689   }
69690   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
69691   return jresult;
69692 }
69693
69694
69695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
69696   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69697
69698   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69699   {
69700     try {
69701       delete arg1;
69702     } catch (std::out_of_range& e) {
69703       {
69704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69705       };
69706     } catch (std::exception& e) {
69707       {
69708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69709       };
69710     } catch (...) {
69711       {
69712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69713       };
69714     }
69715   }
69716 }
69717
69718
69719 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
69720   unsigned int jresult ;
69721   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69722   unsigned int result;
69723
69724   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69725   {
69726     try {
69727       result = (unsigned int)(arg1)->GetNumberOfItems();
69728     } catch (std::out_of_range& e) {
69729       {
69730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69731       };
69732     } catch (std::exception& e) {
69733       {
69734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69735       };
69736     } catch (...) {
69737       {
69738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69739       };
69740     }
69741   }
69742   jresult = result;
69743   return jresult;
69744 }
69745
69746
69747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
69748   void * jresult ;
69749   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69750   unsigned int arg2 ;
69751   Dali::Actor result;
69752
69753   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69754   arg2 = (unsigned int)jarg2;
69755   {
69756     try {
69757       result = (arg1)->NewItem(arg2);
69758     } catch (std::out_of_range& e) {
69759       {
69760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69761       };
69762     } catch (std::exception& e) {
69763       {
69764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69765       };
69766     } catch (...) {
69767       {
69768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69769       };
69770     }
69771   }
69772   jresult = new Dali::Actor((const Dali::Actor &)result);
69773   return jresult;
69774 }
69775
69776
69777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
69778   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69779   unsigned int arg2 ;
69780   Dali::Actor arg3 ;
69781   Dali::Actor *argp3 ;
69782
69783   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69784   arg2 = (unsigned int)jarg2;
69785   argp3 = (Dali::Actor *)jarg3;
69786   if (!argp3) {
69787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69788     return ;
69789   }
69790   arg3 = *argp3;
69791   {
69792     try {
69793       (arg1)->ItemReleased(arg2,arg3);
69794     } catch (std::out_of_range& e) {
69795       {
69796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69797       };
69798     } catch (std::exception& e) {
69799       {
69800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69801       };
69802     } catch (...) {
69803       {
69804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69805       };
69806     }
69807   }
69808 }
69809
69810
69811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
69812   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69813   unsigned int arg2 ;
69814   Dali::Actor arg3 ;
69815   Dali::Actor *argp3 ;
69816
69817   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69818   arg2 = (unsigned int)jarg2;
69819   argp3 = (Dali::Actor *)jarg3;
69820   if (!argp3) {
69821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69822     return ;
69823   }
69824   arg3 = *argp3;
69825   {
69826     try {
69827       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
69828     } catch (std::out_of_range& e) {
69829       {
69830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69831       };
69832     } catch (std::exception& e) {
69833       {
69834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69835       };
69836     } catch (...) {
69837       {
69838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69839       };
69840     }
69841   }
69842 }
69843
69844
69845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
69846   void * jresult ;
69847   Dali::Toolkit::ItemFactory *result = 0 ;
69848
69849   {
69850     try {
69851       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
69852     } catch (std::out_of_range& e) {
69853       {
69854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69855       };
69856     } catch (std::exception& e) {
69857       {
69858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69859       };
69860     } catch (...) {
69861       {
69862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69863       };
69864     }
69865   }
69866   jresult = (void *)result;
69867   return jresult;
69868 }
69869
69870
69871 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) {
69872   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
69873   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
69874   if (director) {
69875     director->swig_connect_director(callback0, callback1, callback2);
69876   }
69877 }
69878
69879
69880 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
69881   int jresult ;
69882   int result;
69883
69884   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
69885   jresult = (int)result;
69886   return jresult;
69887 }
69888
69889
69890 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
69891   int jresult ;
69892   int result;
69893
69894   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
69895   jresult = (int)result;
69896   return jresult;
69897 }
69898
69899
69900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
69901   int jresult ;
69902   int result;
69903
69904   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
69905   jresult = (int)result;
69906   return jresult;
69907 }
69908
69909
69910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
69911   int jresult ;
69912   int result;
69913
69914   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
69915   jresult = (int)result;
69916   return jresult;
69917 }
69918
69919
69920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
69921   int jresult ;
69922   int result;
69923
69924   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
69925   jresult = (int)result;
69926   return jresult;
69927 }
69928
69929
69930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
69931   int jresult ;
69932   int result;
69933
69934   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
69935   jresult = (int)result;
69936   return jresult;
69937 }
69938
69939
69940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
69941   int jresult ;
69942   int result;
69943
69944   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
69945   jresult = (int)result;
69946   return jresult;
69947 }
69948
69949
69950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
69951   int jresult ;
69952   int result;
69953
69954   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
69955   jresult = (int)result;
69956   return jresult;
69957 }
69958
69959
69960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
69961   int jresult ;
69962   int result;
69963
69964   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
69965   jresult = (int)result;
69966   return jresult;
69967 }
69968
69969
69970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
69971   int jresult ;
69972   int result;
69973
69974   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
69975   jresult = (int)result;
69976   return jresult;
69977 }
69978
69979
69980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
69981   int jresult ;
69982   int result;
69983
69984   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
69985   jresult = (int)result;
69986   return jresult;
69987 }
69988
69989
69990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
69991   void * jresult ;
69992   Dali::Toolkit::ItemView::Property *result = 0 ;
69993
69994   {
69995     try {
69996       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
69997     } catch (std::out_of_range& e) {
69998       {
69999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70000       };
70001     } catch (std::exception& e) {
70002       {
70003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70004       };
70005     } catch (...) {
70006       {
70007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70008       };
70009     }
70010   }
70011   jresult = (void *)result;
70012   return jresult;
70013 }
70014
70015
70016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
70017   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
70018
70019   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
70020   {
70021     try {
70022       delete arg1;
70023     } catch (std::out_of_range& e) {
70024       {
70025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70026       };
70027     } catch (std::exception& e) {
70028       {
70029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70030       };
70031     } catch (...) {
70032       {
70033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70034       };
70035     }
70036   }
70037 }
70038
70039
70040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
70041   void * jresult ;
70042   Dali::Toolkit::ItemView *result = 0 ;
70043
70044   {
70045     try {
70046       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
70047     } catch (std::out_of_range& e) {
70048       {
70049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70050       };
70051     } catch (std::exception& e) {
70052       {
70053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70054       };
70055     } catch (...) {
70056       {
70057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70058       };
70059     }
70060   }
70061   jresult = (void *)result;
70062   return jresult;
70063 }
70064
70065
70066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
70067   void * jresult ;
70068   Dali::Toolkit::ItemView *arg1 = 0 ;
70069   Dali::Toolkit::ItemView *result = 0 ;
70070
70071   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70072   if (!arg1) {
70073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70074     return 0;
70075   }
70076   {
70077     try {
70078       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
70079     } catch (std::out_of_range& e) {
70080       {
70081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70082       };
70083     } catch (std::exception& e) {
70084       {
70085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70086       };
70087     } catch (...) {
70088       {
70089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70090       };
70091     }
70092   }
70093   jresult = (void *)result;
70094   return jresult;
70095 }
70096
70097
70098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
70099   void * jresult ;
70100   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70101   Dali::Toolkit::ItemView *arg2 = 0 ;
70102   Dali::Toolkit::ItemView *result = 0 ;
70103
70104   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70105   arg2 = (Dali::Toolkit::ItemView *)jarg2;
70106   if (!arg2) {
70107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70108     return 0;
70109   }
70110   {
70111     try {
70112       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
70113     } catch (std::out_of_range& e) {
70114       {
70115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70116       };
70117     } catch (std::exception& e) {
70118       {
70119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70120       };
70121     } catch (...) {
70122       {
70123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70124       };
70125     }
70126   }
70127   jresult = (void *)result;
70128   return jresult;
70129 }
70130
70131
70132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
70133   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70134
70135   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70136   {
70137     try {
70138       delete arg1;
70139     } catch (std::out_of_range& e) {
70140       {
70141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70142       };
70143     } catch (std::exception& e) {
70144       {
70145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70146       };
70147     } catch (...) {
70148       {
70149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70150       };
70151     }
70152   }
70153 }
70154
70155
70156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
70157   void * jresult ;
70158   Dali::Toolkit::ItemFactory *arg1 = 0 ;
70159   Dali::Toolkit::ItemView result;
70160
70161   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70162   if (!arg1) {
70163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
70164     return 0;
70165   }
70166   {
70167     try {
70168       result = Dali::Toolkit::ItemView::New(*arg1);
70169     } catch (std::out_of_range& e) {
70170       {
70171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70172       };
70173     } catch (std::exception& e) {
70174       {
70175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70176       };
70177     } catch (...) {
70178       {
70179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70180       };
70181     }
70182   }
70183   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
70184   return jresult;
70185 }
70186
70187
70188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
70189   void * jresult ;
70190   Dali::BaseHandle arg1 ;
70191   Dali::BaseHandle *argp1 ;
70192   Dali::Toolkit::ItemView result;
70193
70194   argp1 = (Dali::BaseHandle *)jarg1;
70195   if (!argp1) {
70196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70197     return 0;
70198   }
70199   arg1 = *argp1;
70200   {
70201     try {
70202       result = Dali::Toolkit::ItemView::DownCast(arg1);
70203     } catch (std::out_of_range& e) {
70204       {
70205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70206       };
70207     } catch (std::exception& e) {
70208       {
70209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70210       };
70211     } catch (...) {
70212       {
70213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70214       };
70215     }
70216   }
70217   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
70218   return jresult;
70219 }
70220
70221
70222 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
70223   unsigned int jresult ;
70224   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70225   unsigned int result;
70226
70227   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70228   {
70229     try {
70230       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
70231     } catch (std::out_of_range& e) {
70232       {
70233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70234       };
70235     } catch (std::exception& e) {
70236       {
70237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70238       };
70239     } catch (...) {
70240       {
70241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70242       };
70243     }
70244   }
70245   jresult = result;
70246   return jresult;
70247 }
70248
70249
70250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
70251   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70252   Dali::Toolkit::ItemLayout *arg2 = 0 ;
70253
70254   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70255   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
70256   if (!arg2) {
70257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
70258     return ;
70259   }
70260   {
70261     try {
70262       (arg1)->AddLayout(*arg2);
70263     } catch (std::out_of_range& e) {
70264       {
70265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70266       };
70267     } catch (std::exception& e) {
70268       {
70269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70270       };
70271     } catch (...) {
70272       {
70273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70274       };
70275     }
70276   }
70277 }
70278
70279
70280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
70281   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70282   unsigned int arg2 ;
70283
70284   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70285   arg2 = (unsigned int)jarg2;
70286   {
70287     try {
70288       (arg1)->RemoveLayout(arg2);
70289     } catch (std::out_of_range& e) {
70290       {
70291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70292       };
70293     } catch (std::exception& e) {
70294       {
70295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70296       };
70297     } catch (...) {
70298       {
70299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70300       };
70301     }
70302   }
70303 }
70304
70305
70306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
70307   void * jresult ;
70308   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70309   unsigned int arg2 ;
70310   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70311
70312   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70313   arg2 = (unsigned int)jarg2;
70314   {
70315     try {
70316       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
70317     } catch (std::out_of_range& e) {
70318       {
70319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70320       };
70321     } catch (std::exception& e) {
70322       {
70323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70324       };
70325     } catch (...) {
70326       {
70327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70328       };
70329     }
70330   }
70331   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70332   return jresult;
70333 }
70334
70335
70336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
70337   void * jresult ;
70338   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70339   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70340
70341   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70342   {
70343     try {
70344       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
70345     } catch (std::out_of_range& e) {
70346       {
70347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70348       };
70349     } catch (std::exception& e) {
70350       {
70351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70352       };
70353     } catch (...) {
70354       {
70355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70356       };
70357     }
70358   }
70359   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70360   return jresult;
70361 }
70362
70363
70364 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
70365   float jresult ;
70366   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70367   Dali::Toolkit::ItemId arg2 ;
70368   float result;
70369
70370   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70371   arg2 = (Dali::Toolkit::ItemId)jarg2;
70372   {
70373     try {
70374       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
70375     } catch (std::out_of_range& e) {
70376       {
70377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70378       };
70379     } catch (std::exception& e) {
70380       {
70381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70382       };
70383     } catch (...) {
70384       {
70385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70386       };
70387     }
70388   }
70389   jresult = result;
70390   return jresult;
70391 }
70392
70393
70394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
70395   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70396   unsigned int arg2 ;
70397   Dali::Vector3 arg3 ;
70398   float arg4 ;
70399   Dali::Vector3 *argp3 ;
70400
70401   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70402   arg2 = (unsigned int)jarg2;
70403   argp3 = (Dali::Vector3 *)jarg3;
70404   if (!argp3) {
70405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
70406     return ;
70407   }
70408   arg3 = *argp3;
70409   arg4 = (float)jarg4;
70410   {
70411     try {
70412       (arg1)->ActivateLayout(arg2,arg3,arg4);
70413     } catch (std::out_of_range& e) {
70414       {
70415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70416       };
70417     } catch (std::exception& e) {
70418       {
70419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70420       };
70421     } catch (...) {
70422       {
70423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70424       };
70425     }
70426   }
70427 }
70428
70429
70430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
70431   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70432
70433   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70434   {
70435     try {
70436       (arg1)->DeactivateCurrentLayout();
70437     } catch (std::out_of_range& e) {
70438       {
70439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70440       };
70441     } catch (std::exception& e) {
70442       {
70443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70444       };
70445     } catch (...) {
70446       {
70447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70448       };
70449     }
70450   }
70451 }
70452
70453
70454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
70455   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70456   float arg2 ;
70457
70458   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70459   arg2 = (float)jarg2;
70460   {
70461     try {
70462       (arg1)->SetMinimumSwipeSpeed(arg2);
70463     } catch (std::out_of_range& e) {
70464       {
70465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70466       };
70467     } catch (std::exception& e) {
70468       {
70469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70470       };
70471     } catch (...) {
70472       {
70473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70474       };
70475     }
70476   }
70477 }
70478
70479
70480 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
70481   float jresult ;
70482   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70483   float result;
70484
70485   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70486   {
70487     try {
70488       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
70489     } catch (std::out_of_range& e) {
70490       {
70491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70492       };
70493     } catch (std::exception& e) {
70494       {
70495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70496       };
70497     } catch (...) {
70498       {
70499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70500       };
70501     }
70502   }
70503   jresult = result;
70504   return jresult;
70505 }
70506
70507
70508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
70509   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70510   float arg2 ;
70511
70512   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70513   arg2 = (float)jarg2;
70514   {
70515     try {
70516       (arg1)->SetMinimumSwipeDistance(arg2);
70517     } catch (std::out_of_range& e) {
70518       {
70519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70520       };
70521     } catch (std::exception& e) {
70522       {
70523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70524       };
70525     } catch (...) {
70526       {
70527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70528       };
70529     }
70530   }
70531 }
70532
70533
70534 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
70535   float jresult ;
70536   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70537   float result;
70538
70539   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70540   {
70541     try {
70542       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
70543     } catch (std::out_of_range& e) {
70544       {
70545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70546       };
70547     } catch (std::exception& e) {
70548       {
70549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70550       };
70551     } catch (...) {
70552       {
70553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70554       };
70555     }
70556   }
70557   jresult = result;
70558   return jresult;
70559 }
70560
70561
70562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
70563   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70564   float arg2 ;
70565
70566   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70567   arg2 = (float)jarg2;
70568   {
70569     try {
70570       (arg1)->SetWheelScrollDistanceStep(arg2);
70571     } catch (std::out_of_range& e) {
70572       {
70573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70574       };
70575     } catch (std::exception& e) {
70576       {
70577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70578       };
70579     } catch (...) {
70580       {
70581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70582       };
70583     }
70584   }
70585 }
70586
70587
70588 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
70589   float jresult ;
70590   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70591   float result;
70592
70593   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70594   {
70595     try {
70596       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
70597     } catch (std::out_of_range& e) {
70598       {
70599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70600       };
70601     } catch (std::exception& e) {
70602       {
70603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70604       };
70605     } catch (...) {
70606       {
70607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70608       };
70609     }
70610   }
70611   jresult = result;
70612   return jresult;
70613 }
70614
70615
70616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
70617   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70618   bool arg2 ;
70619
70620   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70621   arg2 = jarg2 ? true : false;
70622   {
70623     try {
70624       (arg1)->SetAnchoring(arg2);
70625     } catch (std::out_of_range& e) {
70626       {
70627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70628       };
70629     } catch (std::exception& e) {
70630       {
70631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70632       };
70633     } catch (...) {
70634       {
70635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70636       };
70637     }
70638   }
70639 }
70640
70641
70642 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
70643   unsigned int jresult ;
70644   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70645   bool result;
70646
70647   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70648   {
70649     try {
70650       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
70651     } catch (std::out_of_range& e) {
70652       {
70653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70654       };
70655     } catch (std::exception& e) {
70656       {
70657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70658       };
70659     } catch (...) {
70660       {
70661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70662       };
70663     }
70664   }
70665   jresult = result;
70666   return jresult;
70667 }
70668
70669
70670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
70671   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70672   float arg2 ;
70673
70674   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70675   arg2 = (float)jarg2;
70676   {
70677     try {
70678       (arg1)->SetAnchoringDuration(arg2);
70679     } catch (std::out_of_range& e) {
70680       {
70681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70682       };
70683     } catch (std::exception& e) {
70684       {
70685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70686       };
70687     } catch (...) {
70688       {
70689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70690       };
70691     }
70692   }
70693 }
70694
70695
70696 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
70697   float jresult ;
70698   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70699   float result;
70700
70701   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70702   {
70703     try {
70704       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
70705     } catch (std::out_of_range& e) {
70706       {
70707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70708       };
70709     } catch (std::exception& e) {
70710       {
70711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70712       };
70713     } catch (...) {
70714       {
70715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70716       };
70717     }
70718   }
70719   jresult = result;
70720   return jresult;
70721 }
70722
70723
70724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
70725   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70726   Dali::Toolkit::ItemId arg2 ;
70727   float arg3 ;
70728
70729   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70730   arg2 = (Dali::Toolkit::ItemId)jarg2;
70731   arg3 = (float)jarg3;
70732   {
70733     try {
70734       (arg1)->ScrollToItem(arg2,arg3);
70735     } catch (std::out_of_range& e) {
70736       {
70737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70738       };
70739     } catch (std::exception& e) {
70740       {
70741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70742       };
70743     } catch (...) {
70744       {
70745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70746       };
70747     }
70748   }
70749 }
70750
70751
70752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
70753   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70754   float arg2 ;
70755
70756   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70757   arg2 = (float)jarg2;
70758   {
70759     try {
70760       (arg1)->SetRefreshInterval(arg2);
70761     } catch (std::out_of_range& e) {
70762       {
70763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70764       };
70765     } catch (std::exception& e) {
70766       {
70767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70768       };
70769     } catch (...) {
70770       {
70771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70772       };
70773     }
70774   }
70775 }
70776
70777
70778 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
70779   float jresult ;
70780   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70781   float result;
70782
70783   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70784   {
70785     try {
70786       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
70787     } catch (std::out_of_range& e) {
70788       {
70789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70790       };
70791     } catch (std::exception& e) {
70792       {
70793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70794       };
70795     } catch (...) {
70796       {
70797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70798       };
70799     }
70800   }
70801   jresult = result;
70802   return jresult;
70803 }
70804
70805
70806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
70807   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70808
70809   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70810   {
70811     try {
70812       (arg1)->Refresh();
70813     } catch (std::out_of_range& e) {
70814       {
70815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70816       };
70817     } catch (std::exception& e) {
70818       {
70819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70820       };
70821     } catch (...) {
70822       {
70823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70824       };
70825     }
70826   }
70827 }
70828
70829
70830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
70831   void * jresult ;
70832   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70833   Dali::Toolkit::ItemId arg2 ;
70834   Dali::Actor result;
70835
70836   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70837   arg2 = (Dali::Toolkit::ItemId)jarg2;
70838   {
70839     try {
70840       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
70841     } catch (std::out_of_range& e) {
70842       {
70843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70844       };
70845     } catch (std::exception& e) {
70846       {
70847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70848       };
70849     } catch (...) {
70850       {
70851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70852       };
70853     }
70854   }
70855   jresult = new Dali::Actor((const Dali::Actor &)result);
70856   return jresult;
70857 }
70858
70859
70860 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
70861   unsigned int jresult ;
70862   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70863   Dali::Actor arg2 ;
70864   Dali::Actor *argp2 ;
70865   Dali::Toolkit::ItemId result;
70866
70867   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70868   argp2 = (Dali::Actor *)jarg2;
70869   if (!argp2) {
70870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70871     return 0;
70872   }
70873   arg2 = *argp2;
70874   {
70875     try {
70876       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
70877     } catch (std::out_of_range& e) {
70878       {
70879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70880       };
70881     } catch (std::exception& e) {
70882       {
70883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70884       };
70885     } catch (...) {
70886       {
70887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70888       };
70889     }
70890   }
70891   jresult = result;
70892   return jresult;
70893 }
70894
70895
70896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
70897   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70898   Dali::Toolkit::Item arg2 ;
70899   float arg3 ;
70900   Dali::Toolkit::Item *argp2 ;
70901
70902   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70903   argp2 = (Dali::Toolkit::Item *)jarg2;
70904   if (!argp2) {
70905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
70906     return ;
70907   }
70908   arg2 = *argp2;
70909   arg3 = (float)jarg3;
70910   {
70911     try {
70912       (arg1)->InsertItem(arg2,arg3);
70913     } catch (std::out_of_range& e) {
70914       {
70915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70916       };
70917     } catch (std::exception& e) {
70918       {
70919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70920       };
70921     } catch (...) {
70922       {
70923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70924       };
70925     }
70926   }
70927 }
70928
70929
70930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
70931   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70932   Dali::Toolkit::ItemContainer *arg2 = 0 ;
70933   float arg3 ;
70934
70935   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70936   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
70937   if (!arg2) {
70938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
70939     return ;
70940   }
70941   arg3 = (float)jarg3;
70942   {
70943     try {
70944       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
70945     } catch (std::out_of_range& e) {
70946       {
70947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70948       };
70949     } catch (std::exception& e) {
70950       {
70951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70952       };
70953     } catch (...) {
70954       {
70955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70956       };
70957     }
70958   }
70959 }
70960
70961
70962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
70963   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70964   Dali::Toolkit::ItemId arg2 ;
70965   float arg3 ;
70966
70967   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70968   arg2 = (Dali::Toolkit::ItemId)jarg2;
70969   arg3 = (float)jarg3;
70970   {
70971     try {
70972       (arg1)->RemoveItem(arg2,arg3);
70973     } catch (std::out_of_range& e) {
70974       {
70975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70976       };
70977     } catch (std::exception& e) {
70978       {
70979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70980       };
70981     } catch (...) {
70982       {
70983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70984       };
70985     }
70986   }
70987 }
70988
70989
70990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
70991   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70992   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
70993   float arg3 ;
70994
70995   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70996   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
70997   if (!arg2) {
70998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
70999     return ;
71000   }
71001   arg3 = (float)jarg3;
71002   {
71003     try {
71004       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
71005     } catch (std::out_of_range& e) {
71006       {
71007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71008       };
71009     } catch (std::exception& e) {
71010       {
71011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71012       };
71013     } catch (...) {
71014       {
71015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71016       };
71017     }
71018   }
71019 }
71020
71021
71022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
71023   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71024   Dali::Toolkit::Item arg2 ;
71025   float arg3 ;
71026   Dali::Toolkit::Item *argp2 ;
71027
71028   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71029   argp2 = (Dali::Toolkit::Item *)jarg2;
71030   if (!argp2) {
71031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71032     return ;
71033   }
71034   arg2 = *argp2;
71035   arg3 = (float)jarg3;
71036   {
71037     try {
71038       (arg1)->ReplaceItem(arg2,arg3);
71039     } catch (std::out_of_range& e) {
71040       {
71041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71042       };
71043     } catch (std::exception& e) {
71044       {
71045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71046       };
71047     } catch (...) {
71048       {
71049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71050       };
71051     }
71052   }
71053 }
71054
71055
71056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
71057   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71058   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71059   float arg3 ;
71060
71061   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71062   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71063   if (!arg2) {
71064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71065     return ;
71066   }
71067   arg3 = (float)jarg3;
71068   {
71069     try {
71070       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71071     } catch (std::out_of_range& e) {
71072       {
71073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71074       };
71075     } catch (std::exception& e) {
71076       {
71077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71078       };
71079     } catch (...) {
71080       {
71081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71082       };
71083     }
71084   }
71085 }
71086
71087
71088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
71089   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71090   Dali::Vector3 *arg2 = 0 ;
71091
71092   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71093   arg2 = (Dali::Vector3 *)jarg2;
71094   if (!arg2) {
71095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71096     return ;
71097   }
71098   {
71099     try {
71100       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
71101     } catch (std::out_of_range& e) {
71102       {
71103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71104       };
71105     } catch (std::exception& e) {
71106       {
71107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71108       };
71109     } catch (...) {
71110       {
71111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71112       };
71113     }
71114   }
71115 }
71116
71117
71118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
71119   void * jresult ;
71120   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71121   Dali::Vector3 result;
71122
71123   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71124   {
71125     try {
71126       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
71127     } catch (std::out_of_range& e) {
71128       {
71129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71130       };
71131     } catch (std::exception& e) {
71132       {
71133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71134       };
71135     } catch (...) {
71136       {
71137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71138       };
71139     }
71140   }
71141   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
71142   return jresult;
71143 }
71144
71145
71146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
71147   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71148   Dali::Vector3 *arg2 = 0 ;
71149
71150   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71151   arg2 = (Dali::Vector3 *)jarg2;
71152   if (!arg2) {
71153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71154     return ;
71155   }
71156   {
71157     try {
71158       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
71159     } catch (std::out_of_range& e) {
71160       {
71161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71162       };
71163     } catch (std::exception& e) {
71164       {
71165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71166       };
71167     } catch (...) {
71168       {
71169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71170       };
71171     }
71172   }
71173 }
71174
71175
71176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
71177   void * jresult ;
71178   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71179   Dali::Vector3 result;
71180
71181   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71182   {
71183     try {
71184       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
71185     } catch (std::out_of_range& e) {
71186       {
71187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71188       };
71189     } catch (std::exception& e) {
71190       {
71191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71192       };
71193     } catch (...) {
71194       {
71195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71196       };
71197     }
71198   }
71199   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
71200   return jresult;
71201 }
71202
71203
71204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
71205   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71206   Dali::Toolkit::ItemRange *arg2 = 0 ;
71207
71208   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71209   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
71210   if (!arg2) {
71211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
71212     return ;
71213   }
71214   {
71215     try {
71216       (arg1)->GetItemsRange(*arg2);
71217     } catch (std::out_of_range& e) {
71218       {
71219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71220       };
71221     } catch (std::exception& e) {
71222       {
71223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71224       };
71225     } catch (...) {
71226       {
71227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71228       };
71229     }
71230   }
71231 }
71232
71233
71234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
71235   void * jresult ;
71236   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71237   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
71238
71239   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71240   {
71241     try {
71242       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
71243     } catch (std::out_of_range& e) {
71244       {
71245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71246       };
71247     } catch (std::exception& e) {
71248       {
71249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71250       };
71251     } catch (...) {
71252       {
71253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71254       };
71255     }
71256   }
71257   jresult = (void *)result;
71258   return jresult;
71259 }
71260
71261
71262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
71263   Dali::Vector3 *arg1 = 0 ;
71264   PropertyInputContainer *arg2 = 0 ;
71265
71266   arg1 = (Dali::Vector3 *)jarg1;
71267   if (!arg1) {
71268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
71269     return ;
71270   }
71271   arg2 = (PropertyInputContainer *)jarg2;
71272   if (!arg2) {
71273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
71274     return ;
71275   }
71276   {
71277     try {
71278       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
71279     } catch (std::out_of_range& e) {
71280       {
71281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71282       };
71283     } catch (std::exception& e) {
71284       {
71285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71286       };
71287     } catch (...) {
71288       {
71289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71290       };
71291     }
71292   }
71293 }
71294
71295
71296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
71297   Dali::Vector3 *arg1 = 0 ;
71298   PropertyInputContainer *arg2 = 0 ;
71299
71300   arg1 = (Dali::Vector3 *)jarg1;
71301   if (!arg1) {
71302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
71303     return ;
71304   }
71305   arg2 = (PropertyInputContainer *)jarg2;
71306   if (!arg2) {
71307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
71308     return ;
71309   }
71310   {
71311     try {
71312       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
71313     } catch (std::out_of_range& e) {
71314       {
71315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71316       };
71317     } catch (std::exception& e) {
71318       {
71319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71320       };
71321     } catch (...) {
71322       {
71323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71324       };
71325     }
71326   }
71327 }
71328
71329
71330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
71331   void * jresult ;
71332   Dali::Toolkit::ScrollViewEffect *result = 0 ;
71333
71334   {
71335     try {
71336       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
71337     } catch (std::out_of_range& e) {
71338       {
71339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71340       };
71341     } catch (std::exception& e) {
71342       {
71343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71344       };
71345     } catch (...) {
71346       {
71347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71348       };
71349     }
71350   }
71351   jresult = (void *)result;
71352   return jresult;
71353 }
71354
71355
71356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
71357   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
71358
71359   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
71360   {
71361     try {
71362       delete arg1;
71363     } catch (std::out_of_range& e) {
71364       {
71365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71366       };
71367     } catch (std::exception& e) {
71368       {
71369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71370       };
71371     } catch (...) {
71372       {
71373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71374       };
71375     }
71376   }
71377 }
71378
71379
71380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
71381   void * jresult ;
71382   Dali::Path arg1 ;
71383   Dali::Vector3 *arg2 = 0 ;
71384   Dali::Property::Index arg3 ;
71385   Dali::Vector3 *arg4 = 0 ;
71386   unsigned int arg5 ;
71387   Dali::Path *argp1 ;
71388   Dali::Toolkit::ScrollViewPagePathEffect result;
71389
71390   argp1 = (Dali::Path *)jarg1;
71391   if (!argp1) {
71392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
71393     return 0;
71394   }
71395   arg1 = *argp1;
71396   arg2 = (Dali::Vector3 *)jarg2;
71397   if (!arg2) {
71398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71399     return 0;
71400   }
71401   arg3 = (Dali::Property::Index)jarg3;
71402   arg4 = (Dali::Vector3 *)jarg4;
71403   if (!arg4) {
71404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71405     return 0;
71406   }
71407   arg5 = (unsigned int)jarg5;
71408   {
71409     try {
71410       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
71411     } catch (std::out_of_range& e) {
71412       {
71413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71414       };
71415     } catch (std::exception& e) {
71416       {
71417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71418       };
71419     } catch (...) {
71420       {
71421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71422       };
71423     }
71424   }
71425   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
71426   return jresult;
71427 }
71428
71429
71430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
71431   void * jresult ;
71432   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
71433
71434   {
71435     try {
71436       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
71437     } catch (std::out_of_range& e) {
71438       {
71439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71440       };
71441     } catch (std::exception& e) {
71442       {
71443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71444       };
71445     } catch (...) {
71446       {
71447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71448       };
71449     }
71450   }
71451   jresult = (void *)result;
71452   return jresult;
71453 }
71454
71455
71456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
71457   void * jresult ;
71458   Dali::BaseHandle arg1 ;
71459   Dali::BaseHandle *argp1 ;
71460   Dali::Toolkit::ScrollViewPagePathEffect result;
71461
71462   argp1 = (Dali::BaseHandle *)jarg1;
71463   if (!argp1) {
71464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71465     return 0;
71466   }
71467   arg1 = *argp1;
71468   {
71469     try {
71470       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
71471     } catch (std::out_of_range& e) {
71472       {
71473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71474       };
71475     } catch (std::exception& e) {
71476       {
71477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71478       };
71479     } catch (...) {
71480       {
71481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71482       };
71483     }
71484   }
71485   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
71486   return jresult;
71487 }
71488
71489
71490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
71491   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
71492   Dali::Actor arg2 ;
71493   unsigned int arg3 ;
71494   Dali::Actor *argp2 ;
71495
71496   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
71497   argp2 = (Dali::Actor *)jarg2;
71498   if (!argp2) {
71499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71500     return ;
71501   }
71502   arg2 = *argp2;
71503   arg3 = (unsigned int)jarg3;
71504   {
71505     try {
71506       (arg1)->ApplyToPage(arg2,arg3);
71507     } catch (std::out_of_range& e) {
71508       {
71509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71510       };
71511     } catch (std::exception& e) {
71512       {
71513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71514       };
71515     } catch (...) {
71516       {
71517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71518       };
71519     }
71520   }
71521 }
71522
71523
71524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
71525   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
71526
71527   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
71528   {
71529     try {
71530       delete arg1;
71531     } catch (std::out_of_range& e) {
71532       {
71533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71534       };
71535     } catch (std::exception& e) {
71536       {
71537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71538       };
71539     } catch (...) {
71540       {
71541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71542       };
71543     }
71544   }
71545 }
71546
71547
71548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
71549   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71550   Dali::Toolkit::ClampState arg2 ;
71551
71552   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71553   arg2 = (Dali::Toolkit::ClampState)jarg2;
71554   if (arg1) (arg1)->x = arg2;
71555 }
71556
71557
71558 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
71559   int jresult ;
71560   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71561   Dali::Toolkit::ClampState result;
71562
71563   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71564   result = (Dali::Toolkit::ClampState) ((arg1)->x);
71565   jresult = (int)result;
71566   return jresult;
71567 }
71568
71569
71570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
71571   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71572   Dali::Toolkit::ClampState arg2 ;
71573
71574   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71575   arg2 = (Dali::Toolkit::ClampState)jarg2;
71576   if (arg1) (arg1)->y = arg2;
71577 }
71578
71579
71580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
71581   int jresult ;
71582   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71583   Dali::Toolkit::ClampState result;
71584
71585   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71586   result = (Dali::Toolkit::ClampState) ((arg1)->y);
71587   jresult = (int)result;
71588   return jresult;
71589 }
71590
71591
71592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
71593   void * jresult ;
71594   Dali::Toolkit::ClampState2D *result = 0 ;
71595
71596   {
71597     try {
71598       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
71599     } catch (std::out_of_range& e) {
71600       {
71601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71602       };
71603     } catch (std::exception& e) {
71604       {
71605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71606       };
71607     } catch (...) {
71608       {
71609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71610       };
71611     }
71612   }
71613   jresult = (void *)result;
71614   return jresult;
71615 }
71616
71617
71618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
71619   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71620
71621   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71622   {
71623     try {
71624       delete arg1;
71625     } catch (std::out_of_range& e) {
71626       {
71627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71628       };
71629     } catch (std::exception& e) {
71630       {
71631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71632       };
71633     } catch (...) {
71634       {
71635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71636       };
71637     }
71638   }
71639 }
71640
71641
71642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
71643   void * jresult ;
71644   float arg1 ;
71645   float arg2 ;
71646   bool arg3 ;
71647   Dali::Toolkit::RulerDomain *result = 0 ;
71648
71649   arg1 = (float)jarg1;
71650   arg2 = (float)jarg2;
71651   arg3 = jarg3 ? true : false;
71652   {
71653     try {
71654       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
71655     } catch (std::out_of_range& e) {
71656       {
71657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71658       };
71659     } catch (std::exception& e) {
71660       {
71661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71662       };
71663     } catch (...) {
71664       {
71665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71666       };
71667     }
71668   }
71669   jresult = (void *)result;
71670   return jresult;
71671 }
71672
71673
71674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
71675   void * jresult ;
71676   float arg1 ;
71677   float arg2 ;
71678   Dali::Toolkit::RulerDomain *result = 0 ;
71679
71680   arg1 = (float)jarg1;
71681   arg2 = (float)jarg2;
71682   {
71683     try {
71684       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
71685     } catch (std::out_of_range& e) {
71686       {
71687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71688       };
71689     } catch (std::exception& e) {
71690       {
71691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71692       };
71693     } catch (...) {
71694       {
71695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71696       };
71697     }
71698   }
71699   jresult = (void *)result;
71700   return jresult;
71701 }
71702
71703
71704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
71705   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71706   float arg2 ;
71707
71708   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71709   arg2 = (float)jarg2;
71710   if (arg1) (arg1)->min = arg2;
71711 }
71712
71713
71714 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
71715   float jresult ;
71716   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71717   float result;
71718
71719   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71720   result = (float) ((arg1)->min);
71721   jresult = result;
71722   return jresult;
71723 }
71724
71725
71726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
71727   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71728   float arg2 ;
71729
71730   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71731   arg2 = (float)jarg2;
71732   if (arg1) (arg1)->max = arg2;
71733 }
71734
71735
71736 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
71737   float jresult ;
71738   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71739   float result;
71740
71741   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71742   result = (float) ((arg1)->max);
71743   jresult = result;
71744   return jresult;
71745 }
71746
71747
71748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
71749   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71750   bool arg2 ;
71751
71752   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71753   arg2 = jarg2 ? true : false;
71754   if (arg1) (arg1)->enabled = arg2;
71755 }
71756
71757
71758 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
71759   unsigned int jresult ;
71760   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71761   bool result;
71762
71763   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71764   result = (bool) ((arg1)->enabled);
71765   jresult = result;
71766   return jresult;
71767 }
71768
71769
71770 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
71771   float jresult ;
71772   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71773   float arg2 ;
71774   float arg3 ;
71775   float arg4 ;
71776   float result;
71777
71778   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71779   arg2 = (float)jarg2;
71780   arg3 = (float)jarg3;
71781   arg4 = (float)jarg4;
71782   {
71783     try {
71784       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
71785     } catch (std::out_of_range& e) {
71786       {
71787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71788       };
71789     } catch (std::exception& e) {
71790       {
71791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71792       };
71793     } catch (...) {
71794       {
71795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71796       };
71797     }
71798   }
71799   jresult = result;
71800   return jresult;
71801 }
71802
71803
71804 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
71805   float jresult ;
71806   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71807   float arg2 ;
71808   float arg3 ;
71809   float result;
71810
71811   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71812   arg2 = (float)jarg2;
71813   arg3 = (float)jarg3;
71814   {
71815     try {
71816       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
71817     } catch (std::out_of_range& e) {
71818       {
71819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71820       };
71821     } catch (std::exception& e) {
71822       {
71823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71824       };
71825     } catch (...) {
71826       {
71827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71828       };
71829     }
71830   }
71831   jresult = result;
71832   return jresult;
71833 }
71834
71835
71836 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
71837   float jresult ;
71838   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71839   float arg2 ;
71840   float result;
71841
71842   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71843   arg2 = (float)jarg2;
71844   {
71845     try {
71846       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
71847     } catch (std::out_of_range& e) {
71848       {
71849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71850       };
71851     } catch (std::exception& e) {
71852       {
71853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71854       };
71855     } catch (...) {
71856       {
71857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71858       };
71859     }
71860   }
71861   jresult = result;
71862   return jresult;
71863 }
71864
71865
71866 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
71867   float jresult ;
71868   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71869   float arg2 ;
71870   float arg3 ;
71871   float arg4 ;
71872   Dali::Toolkit::ClampState *arg5 = 0 ;
71873   float result;
71874
71875   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71876   arg2 = (float)jarg2;
71877   arg3 = (float)jarg3;
71878   arg4 = (float)jarg4;
71879   arg5 = (Dali::Toolkit::ClampState *)jarg5;
71880   if (!arg5) {
71881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
71882     return 0;
71883   }
71884   {
71885     try {
71886       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
71887     } catch (std::out_of_range& e) {
71888       {
71889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71890       };
71891     } catch (std::exception& e) {
71892       {
71893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71894       };
71895     } catch (...) {
71896       {
71897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71898       };
71899     }
71900   }
71901   jresult = result;
71902   return jresult;
71903 }
71904
71905
71906 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
71907   float jresult ;
71908   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71909   float result;
71910
71911   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71912   {
71913     try {
71914       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
71915     } catch (std::out_of_range& e) {
71916       {
71917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71918       };
71919     } catch (std::exception& e) {
71920       {
71921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71922       };
71923     } catch (...) {
71924       {
71925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71926       };
71927     }
71928   }
71929   jresult = result;
71930   return jresult;
71931 }
71932
71933
71934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
71935   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71936
71937   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71938   {
71939     try {
71940       delete arg1;
71941     } catch (std::out_of_range& e) {
71942       {
71943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71944       };
71945     } catch (std::exception& e) {
71946       {
71947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71948       };
71949     } catch (...) {
71950       {
71951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71952       };
71953     }
71954   }
71955 }
71956
71957
71958 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
71959   float jresult ;
71960   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71961   float arg2 ;
71962   float arg3 ;
71963   float result;
71964
71965   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71966   arg2 = (float)jarg2;
71967   arg3 = (float)jarg3;
71968   {
71969     try {
71970       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
71971     } catch (std::out_of_range& e) {
71972       {
71973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71974       };
71975     } catch (std::exception& e) {
71976       {
71977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71978       };
71979     } catch (...) {
71980       {
71981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71982       };
71983     }
71984   }
71985   jresult = result;
71986   return jresult;
71987 }
71988
71989
71990 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
71991   float jresult ;
71992   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71993   float arg2 ;
71994   float result;
71995
71996   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71997   arg2 = (float)jarg2;
71998   {
71999     try {
72000       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
72001     } catch (std::out_of_range& e) {
72002       {
72003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72004       };
72005     } catch (std::exception& e) {
72006       {
72007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72008       };
72009     } catch (...) {
72010       {
72011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72012       };
72013     }
72014   }
72015   jresult = result;
72016   return jresult;
72017 }
72018
72019
72020 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
72021   float jresult ;
72022   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72023   unsigned int arg2 ;
72024   unsigned int *arg3 = 0 ;
72025   bool arg4 ;
72026   float result;
72027
72028   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72029   arg2 = (unsigned int)jarg2;
72030   arg3 = (unsigned int *)jarg3;
72031   arg4 = jarg4 ? true : false;
72032   {
72033     try {
72034       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
72035     } catch (std::out_of_range& e) {
72036       {
72037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72038       };
72039     } catch (std::exception& e) {
72040       {
72041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72042       };
72043     } catch (...) {
72044       {
72045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72046       };
72047     }
72048   }
72049   jresult = result;
72050   return jresult;
72051 }
72052
72053
72054 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
72055   unsigned int jresult ;
72056   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72057   float arg2 ;
72058   bool arg3 ;
72059   unsigned int result;
72060
72061   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72062   arg2 = (float)jarg2;
72063   arg3 = jarg3 ? true : false;
72064   {
72065     try {
72066       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
72067     } catch (std::out_of_range& e) {
72068       {
72069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72070       };
72071     } catch (std::exception& e) {
72072       {
72073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72074       };
72075     } catch (...) {
72076       {
72077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72078       };
72079     }
72080   }
72081   jresult = result;
72082   return jresult;
72083 }
72084
72085
72086 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
72087   unsigned int jresult ;
72088   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72089   unsigned int result;
72090
72091   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72092   {
72093     try {
72094       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
72095     } catch (std::out_of_range& e) {
72096       {
72097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72098       };
72099     } catch (std::exception& e) {
72100       {
72101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72102       };
72103     } catch (...) {
72104       {
72105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72106       };
72107     }
72108   }
72109   jresult = result;
72110   return jresult;
72111 }
72112
72113
72114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
72115   int jresult ;
72116   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72117   Dali::Toolkit::Ruler::RulerType result;
72118
72119   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72120   {
72121     try {
72122       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
72123     } catch (std::out_of_range& e) {
72124       {
72125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72126       };
72127     } catch (std::exception& e) {
72128       {
72129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72130       };
72131     } catch (...) {
72132       {
72133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72134       };
72135     }
72136   }
72137   jresult = (int)result;
72138   return jresult;
72139 }
72140
72141
72142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
72143   unsigned int jresult ;
72144   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72145   bool result;
72146
72147   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72148   {
72149     try {
72150       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
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 void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
72171   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72172
72173   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72174   {
72175     try {
72176       (arg1)->Enable();
72177     } catch (std::out_of_range& e) {
72178       {
72179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72180       };
72181     } catch (std::exception& e) {
72182       {
72183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72184       };
72185     } catch (...) {
72186       {
72187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72188       };
72189     }
72190   }
72191 }
72192
72193
72194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
72195   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72196
72197   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72198   {
72199     try {
72200       (arg1)->Disable();
72201     } catch (std::out_of_range& e) {
72202       {
72203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72204       };
72205     } catch (std::exception& e) {
72206       {
72207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72208       };
72209     } catch (...) {
72210       {
72211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72212       };
72213     }
72214   }
72215 }
72216
72217
72218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
72219   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72220   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
72221   Dali::Toolkit::RulerDomain *argp2 ;
72222
72223   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72224   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
72225   if (!argp2) {
72226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
72227     return ;
72228   }
72229   arg2 = *argp2;
72230   {
72231     try {
72232       (arg1)->SetDomain(arg2);
72233     } catch (std::out_of_range& e) {
72234       {
72235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72236       };
72237     } catch (std::exception& e) {
72238       {
72239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72240       };
72241     } catch (...) {
72242       {
72243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72244       };
72245     }
72246   }
72247 }
72248
72249
72250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
72251   void * jresult ;
72252   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72253   Dali::Toolkit::RulerDomain *result = 0 ;
72254
72255   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72256   {
72257     try {
72258       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
72259     } catch (std::out_of_range& e) {
72260       {
72261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72262       };
72263     } catch (std::exception& e) {
72264       {
72265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72266       };
72267     } catch (...) {
72268       {
72269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72270       };
72271     }
72272   }
72273   jresult = (void *)result;
72274   return jresult;
72275 }
72276
72277
72278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
72279   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72280
72281   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72282   {
72283     try {
72284       (arg1)->DisableDomain();
72285     } catch (std::out_of_range& e) {
72286       {
72287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72288       };
72289     } catch (std::exception& e) {
72290       {
72291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72292       };
72293     } catch (...) {
72294       {
72295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72296       };
72297     }
72298   }
72299 }
72300
72301
72302 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
72303   float jresult ;
72304   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72305   float arg2 ;
72306   float arg3 ;
72307   float arg4 ;
72308   float result;
72309
72310   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72311   arg2 = (float)jarg2;
72312   arg3 = (float)jarg3;
72313   arg4 = (float)jarg4;
72314   {
72315     try {
72316       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
72317     } catch (std::out_of_range& e) {
72318       {
72319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72320       };
72321     } catch (std::exception& e) {
72322       {
72323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72324       };
72325     } catch (...) {
72326       {
72327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72328       };
72329     }
72330   }
72331   jresult = result;
72332   return jresult;
72333 }
72334
72335
72336 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
72337   float jresult ;
72338   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72339   float arg2 ;
72340   float arg3 ;
72341   float result;
72342
72343   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72344   arg2 = (float)jarg2;
72345   arg3 = (float)jarg3;
72346   {
72347     try {
72348       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
72349     } catch (std::out_of_range& e) {
72350       {
72351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72352       };
72353     } catch (std::exception& e) {
72354       {
72355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72356       };
72357     } catch (...) {
72358       {
72359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72360       };
72361     }
72362   }
72363   jresult = result;
72364   return jresult;
72365 }
72366
72367
72368 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
72369   float jresult ;
72370   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72371   float arg2 ;
72372   float result;
72373
72374   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72375   arg2 = (float)jarg2;
72376   {
72377     try {
72378       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
72379     } catch (std::out_of_range& e) {
72380       {
72381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72382       };
72383     } catch (std::exception& e) {
72384       {
72385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72386       };
72387     } catch (...) {
72388       {
72389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72390       };
72391     }
72392   }
72393   jresult = result;
72394   return jresult;
72395 }
72396
72397
72398 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
72399   float jresult ;
72400   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72401   float arg2 ;
72402   float arg3 ;
72403   float arg4 ;
72404   Dali::Toolkit::ClampState *arg5 = 0 ;
72405   float result;
72406
72407   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72408   arg2 = (float)jarg2;
72409   arg3 = (float)jarg3;
72410   arg4 = (float)jarg4;
72411   arg5 = (Dali::Toolkit::ClampState *)jarg5;
72412   if (!arg5) {
72413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
72414     return 0;
72415   }
72416   {
72417     try {
72418       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
72419     } catch (std::out_of_range& e) {
72420       {
72421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72422       };
72423     } catch (std::exception& e) {
72424       {
72425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72426       };
72427     } catch (...) {
72428       {
72429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72430       };
72431     }
72432   }
72433   jresult = result;
72434   return jresult;
72435 }
72436
72437
72438 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
72439   float jresult ;
72440   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72441   float arg2 ;
72442   float arg3 ;
72443   float arg4 ;
72444   float arg5 ;
72445   float result;
72446
72447   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72448   arg2 = (float)jarg2;
72449   arg3 = (float)jarg3;
72450   arg4 = (float)jarg4;
72451   arg5 = (float)jarg5;
72452   {
72453     try {
72454       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
72455     } catch (std::out_of_range& e) {
72456       {
72457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72458       };
72459     } catch (std::exception& e) {
72460       {
72461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72462       };
72463     } catch (...) {
72464       {
72465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72466       };
72467     }
72468   }
72469   jresult = result;
72470   return jresult;
72471 }
72472
72473
72474 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
72475   float jresult ;
72476   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72477   float arg2 ;
72478   float arg3 ;
72479   float arg4 ;
72480   float result;
72481
72482   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72483   arg2 = (float)jarg2;
72484   arg3 = (float)jarg3;
72485   arg4 = (float)jarg4;
72486   {
72487     try {
72488       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
72489     } catch (std::out_of_range& e) {
72490       {
72491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72492       };
72493     } catch (std::exception& e) {
72494       {
72495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72496       };
72497     } catch (...) {
72498       {
72499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72500       };
72501     }
72502   }
72503   jresult = result;
72504   return jresult;
72505 }
72506
72507
72508 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
72509   float jresult ;
72510   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72511   float arg2 ;
72512   float arg3 ;
72513   float result;
72514
72515   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72516   arg2 = (float)jarg2;
72517   arg3 = (float)jarg3;
72518   {
72519     try {
72520       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
72521     } catch (std::out_of_range& e) {
72522       {
72523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72524       };
72525     } catch (std::exception& e) {
72526       {
72527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72528       };
72529     } catch (...) {
72530       {
72531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72532       };
72533     }
72534   }
72535   jresult = result;
72536   return jresult;
72537 }
72538
72539
72540 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
72541   float jresult ;
72542   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72543   float arg2 ;
72544   float result;
72545
72546   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72547   arg2 = (float)jarg2;
72548   {
72549     try {
72550       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
72551     } catch (std::out_of_range& e) {
72552       {
72553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72554       };
72555     } catch (std::exception& e) {
72556       {
72557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72558       };
72559     } catch (...) {
72560       {
72561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72562       };
72563     }
72564   }
72565   jresult = result;
72566   return jresult;
72567 }
72568
72569
72570 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
72571   float jresult ;
72572   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72573   float arg2 ;
72574   float arg3 ;
72575   float arg4 ;
72576   float arg5 ;
72577   Dali::Toolkit::ClampState *arg6 = 0 ;
72578   float result;
72579
72580   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72581   arg2 = (float)jarg2;
72582   arg3 = (float)jarg3;
72583   arg4 = (float)jarg4;
72584   arg5 = (float)jarg5;
72585   arg6 = (Dali::Toolkit::ClampState *)jarg6;
72586   if (!arg6) {
72587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
72588     return 0;
72589   }
72590   {
72591     try {
72592       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
72593     } catch (std::out_of_range& e) {
72594       {
72595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72596       };
72597     } catch (std::exception& e) {
72598       {
72599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72600       };
72601     } catch (...) {
72602       {
72603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72604       };
72605     }
72606   }
72607   jresult = result;
72608   return jresult;
72609 }
72610
72611
72612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
72613   void * jresult ;
72614   Dali::Toolkit::DefaultRuler *result = 0 ;
72615
72616   {
72617     try {
72618       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
72619     } catch (std::out_of_range& e) {
72620       {
72621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72622       };
72623     } catch (std::exception& e) {
72624       {
72625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72626       };
72627     } catch (...) {
72628       {
72629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72630       };
72631     }
72632   }
72633   jresult = (void *)result;
72634   return jresult;
72635 }
72636
72637
72638 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
72639   float jresult ;
72640   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72641   float arg2 ;
72642   float arg3 ;
72643   float result;
72644
72645   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72646   arg2 = (float)jarg2;
72647   arg3 = (float)jarg3;
72648   {
72649     try {
72650       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
72651     } catch (std::out_of_range& e) {
72652       {
72653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72654       };
72655     } catch (std::exception& e) {
72656       {
72657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72658       };
72659     } catch (...) {
72660       {
72661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72662       };
72663     }
72664   }
72665   jresult = result;
72666   return jresult;
72667 }
72668
72669
72670 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
72671   float jresult ;
72672   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72673   unsigned int arg2 ;
72674   unsigned int *arg3 = 0 ;
72675   bool arg4 ;
72676   float result;
72677
72678   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72679   arg2 = (unsigned int)jarg2;
72680   arg3 = (unsigned int *)jarg3;
72681   arg4 = jarg4 ? true : false;
72682   {
72683     try {
72684       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
72685     } catch (std::out_of_range& e) {
72686       {
72687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72688       };
72689     } catch (std::exception& e) {
72690       {
72691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72692       };
72693     } catch (...) {
72694       {
72695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72696       };
72697     }
72698   }
72699   jresult = result;
72700   return jresult;
72701 }
72702
72703
72704 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
72705   unsigned int jresult ;
72706   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72707   float arg2 ;
72708   bool arg3 ;
72709   unsigned int result;
72710
72711   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72712   arg2 = (float)jarg2;
72713   arg3 = jarg3 ? true : false;
72714   {
72715     try {
72716       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
72717     } catch (std::out_of_range& e) {
72718       {
72719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72720       };
72721     } catch (std::exception& e) {
72722       {
72723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72724       };
72725     } catch (...) {
72726       {
72727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72728       };
72729     }
72730   }
72731   jresult = result;
72732   return jresult;
72733 }
72734
72735
72736 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
72737   unsigned int jresult ;
72738   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72739   unsigned int result;
72740
72741   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72742   {
72743     try {
72744       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
72745     } catch (std::out_of_range& e) {
72746       {
72747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72748       };
72749     } catch (std::exception& e) {
72750       {
72751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72752       };
72753     } catch (...) {
72754       {
72755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72756       };
72757     }
72758   }
72759   jresult = result;
72760   return jresult;
72761 }
72762
72763
72764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
72765   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72766
72767   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72768   {
72769     try {
72770       delete arg1;
72771     } catch (std::out_of_range& e) {
72772       {
72773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72774       };
72775     } catch (std::exception& e) {
72776       {
72777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72778       };
72779     } catch (...) {
72780       {
72781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72782       };
72783     }
72784   }
72785 }
72786
72787
72788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
72789   void * jresult ;
72790   float arg1 ;
72791   Dali::Toolkit::FixedRuler *result = 0 ;
72792
72793   arg1 = (float)jarg1;
72794   {
72795     try {
72796       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
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_new_FixedRuler__SWIG_1() {
72817   void * jresult ;
72818   Dali::Toolkit::FixedRuler *result = 0 ;
72819
72820   {
72821     try {
72822       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
72823     } catch (std::out_of_range& e) {
72824       {
72825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72826       };
72827     } catch (std::exception& e) {
72828       {
72829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72830       };
72831     } catch (...) {
72832       {
72833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72834       };
72835     }
72836   }
72837   jresult = (void *)result;
72838   return jresult;
72839 }
72840
72841
72842 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
72843   float jresult ;
72844   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72845   float arg2 ;
72846   float arg3 ;
72847   float result;
72848
72849   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72850   arg2 = (float)jarg2;
72851   arg3 = (float)jarg3;
72852   {
72853     try {
72854       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
72855     } catch (std::out_of_range& e) {
72856       {
72857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72858       };
72859     } catch (std::exception& e) {
72860       {
72861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72862       };
72863     } catch (...) {
72864       {
72865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72866       };
72867     }
72868   }
72869   jresult = result;
72870   return jresult;
72871 }
72872
72873
72874 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
72875   float jresult ;
72876   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72877   unsigned int arg2 ;
72878   unsigned int *arg3 = 0 ;
72879   bool arg4 ;
72880   float result;
72881
72882   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72883   arg2 = (unsigned int)jarg2;
72884   arg3 = (unsigned int *)jarg3;
72885   arg4 = jarg4 ? true : false;
72886   {
72887     try {
72888       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
72889     } catch (std::out_of_range& e) {
72890       {
72891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72892       };
72893     } catch (std::exception& e) {
72894       {
72895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72896       };
72897     } catch (...) {
72898       {
72899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72900       };
72901     }
72902   }
72903   jresult = result;
72904   return jresult;
72905 }
72906
72907
72908 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
72909   unsigned int jresult ;
72910   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72911   float arg2 ;
72912   bool arg3 ;
72913   unsigned int result;
72914
72915   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72916   arg2 = (float)jarg2;
72917   arg3 = jarg3 ? true : false;
72918   {
72919     try {
72920       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
72921     } catch (std::out_of_range& e) {
72922       {
72923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72924       };
72925     } catch (std::exception& e) {
72926       {
72927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72928       };
72929     } catch (...) {
72930       {
72931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72932       };
72933     }
72934   }
72935   jresult = result;
72936   return jresult;
72937 }
72938
72939
72940 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
72941   unsigned int jresult ;
72942   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72943   unsigned int result;
72944
72945   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72946   {
72947     try {
72948       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
72949     } catch (std::out_of_range& e) {
72950       {
72951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72952       };
72953     } catch (std::exception& e) {
72954       {
72955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72956       };
72957     } catch (...) {
72958       {
72959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72960       };
72961     }
72962   }
72963   jresult = result;
72964   return jresult;
72965 }
72966
72967
72968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
72969   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72970
72971   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72972   {
72973     try {
72974       delete arg1;
72975     } catch (std::out_of_range& e) {
72976       {
72977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72978       };
72979     } catch (std::exception& e) {
72980       {
72981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72982       };
72983     } catch (...) {
72984       {
72985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72986       };
72987     }
72988   }
72989 }
72990
72991
72992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
72993   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72994   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
72995
72996   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72997   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
72998   if (arg1) (arg1)->scale = *arg2;
72999 }
73000
73001
73002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
73003   void * jresult ;
73004   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73005   Dali::Toolkit::ClampState2D *result = 0 ;
73006
73007   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73008   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
73009   jresult = (void *)result;
73010   return jresult;
73011 }
73012
73013
73014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
73015   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73016   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
73017
73018   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73019   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
73020   if (arg1) (arg1)->position = *arg2;
73021 }
73022
73023
73024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
73025   void * jresult ;
73026   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73027   Dali::Toolkit::ClampState2D *result = 0 ;
73028
73029   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73030   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
73031   jresult = (void *)result;
73032   return jresult;
73033 }
73034
73035
73036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
73037   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73038   Dali::Toolkit::ClampState arg2 ;
73039
73040   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73041   arg2 = (Dali::Toolkit::ClampState)jarg2;
73042   if (arg1) (arg1)->rotation = arg2;
73043 }
73044
73045
73046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
73047   int jresult ;
73048   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73049   Dali::Toolkit::ClampState result;
73050
73051   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73052   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
73053   jresult = (int)result;
73054   return jresult;
73055 }
73056
73057
73058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
73059   void * jresult ;
73060   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
73061
73062   {
73063     try {
73064       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
73065     } catch (std::out_of_range& e) {
73066       {
73067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73068       };
73069     } catch (std::exception& e) {
73070       {
73071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73072       };
73073     } catch (...) {
73074       {
73075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73076       };
73077     }
73078   }
73079   jresult = (void *)result;
73080   return jresult;
73081 }
73082
73083
73084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
73085   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73086
73087   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73088   {
73089     try {
73090       delete arg1;
73091     } catch (std::out_of_range& e) {
73092       {
73093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73094       };
73095     } catch (std::exception& e) {
73096       {
73097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73098       };
73099     } catch (...) {
73100       {
73101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73102       };
73103     }
73104   }
73105 }
73106
73107
73108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
73109   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73110   Dali::Toolkit::SnapType arg2 ;
73111
73112   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73113   arg2 = (Dali::Toolkit::SnapType)jarg2;
73114   if (arg1) (arg1)->type = arg2;
73115 }
73116
73117
73118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
73119   int jresult ;
73120   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73121   Dali::Toolkit::SnapType result;
73122
73123   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73124   result = (Dali::Toolkit::SnapType) ((arg1)->type);
73125   jresult = (int)result;
73126   return jresult;
73127 }
73128
73129
73130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
73131   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73132   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
73133
73134   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73135   arg2 = (Dali::Vector2 *)jarg2;
73136   if (arg1) (arg1)->position = *arg2;
73137 }
73138
73139
73140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
73141   void * jresult ;
73142   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73143   Dali::Vector2 *result = 0 ;
73144
73145   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73146   result = (Dali::Vector2 *)& ((arg1)->position);
73147   jresult = (void *)result;
73148   return jresult;
73149 }
73150
73151
73152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
73153   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73154   float arg2 ;
73155
73156   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73157   arg2 = (float)jarg2;
73158   if (arg1) (arg1)->duration = arg2;
73159 }
73160
73161
73162 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
73163   float jresult ;
73164   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73165   float result;
73166
73167   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73168   result = (float) ((arg1)->duration);
73169   jresult = result;
73170   return jresult;
73171 }
73172
73173
73174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
73175   void * jresult ;
73176   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
73177
73178   {
73179     try {
73180       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
73181     } catch (std::out_of_range& e) {
73182       {
73183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73184       };
73185     } catch (std::exception& e) {
73186       {
73187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73188       };
73189     } catch (...) {
73190       {
73191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73192       };
73193     }
73194   }
73195   jresult = (void *)result;
73196   return jresult;
73197 }
73198
73199
73200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
73201   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73202
73203   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73204   {
73205     try {
73206       delete arg1;
73207     } catch (std::out_of_range& e) {
73208       {
73209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73210       };
73211     } catch (std::exception& e) {
73212       {
73213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73214       };
73215     } catch (...) {
73216       {
73217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73218       };
73219     }
73220   }
73221 }
73222
73223
73224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
73225   int jresult ;
73226   int result;
73227
73228   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
73229   jresult = (int)result;
73230   return jresult;
73231 }
73232
73233
73234 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
73235   int jresult ;
73236   int result;
73237
73238   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
73239   jresult = (int)result;
73240   return jresult;
73241 }
73242
73243
73244 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
73245   int jresult ;
73246   int result;
73247
73248   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
73249   jresult = (int)result;
73250   return jresult;
73251 }
73252
73253
73254 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
73255   int jresult ;
73256   int result;
73257
73258   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
73259   jresult = (int)result;
73260   return jresult;
73261 }
73262
73263
73264 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
73265   int jresult ;
73266   int result;
73267
73268   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
73269   jresult = (int)result;
73270   return jresult;
73271 }
73272
73273
73274 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
73275   int jresult ;
73276   int result;
73277
73278   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
73279   jresult = (int)result;
73280   return jresult;
73281 }
73282
73283
73284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
73285   int jresult ;
73286   int result;
73287
73288   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
73289   jresult = (int)result;
73290   return jresult;
73291 }
73292
73293
73294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
73295   int jresult ;
73296   int result;
73297
73298   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
73299   jresult = (int)result;
73300   return jresult;
73301 }
73302
73303
73304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
73305   int jresult ;
73306   int result;
73307
73308   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
73309   jresult = (int)result;
73310   return jresult;
73311 }
73312
73313
73314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
73315   int jresult ;
73316   int result;
73317
73318   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
73319   jresult = (int)result;
73320   return jresult;
73321 }
73322
73323
73324 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
73325   int jresult ;
73326   int result;
73327
73328   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
73329   jresult = (int)result;
73330   return jresult;
73331 }
73332
73333
73334 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
73335   int jresult ;
73336   int result;
73337
73338   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
73339   jresult = (int)result;
73340   return jresult;
73341 }
73342
73343
73344 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
73345   int jresult ;
73346   int result;
73347
73348   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
73349   jresult = (int)result;
73350   return jresult;
73351 }
73352
73353
73354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
73355   int jresult ;
73356   int result;
73357
73358   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
73359   jresult = (int)result;
73360   return jresult;
73361 }
73362
73363
73364 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
73365   int jresult ;
73366   int result;
73367
73368   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
73369   jresult = (int)result;
73370   return jresult;
73371 }
73372
73373
73374 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
73375   int jresult ;
73376   int result;
73377
73378   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
73379   jresult = (int)result;
73380   return jresult;
73381 }
73382
73383
73384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
73385   int jresult ;
73386   int result;
73387
73388   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
73389   jresult = (int)result;
73390   return jresult;
73391 }
73392
73393
73394 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
73395   int jresult ;
73396   int result;
73397
73398   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
73399   jresult = (int)result;
73400   return jresult;
73401 }
73402
73403
73404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
73405   int jresult ;
73406   int result;
73407
73408   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
73409   jresult = (int)result;
73410   return jresult;
73411 }
73412
73413
73414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
73415   int jresult ;
73416   int result;
73417
73418   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
73419   jresult = (int)result;
73420   return jresult;
73421 }
73422
73423
73424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
73425   int jresult ;
73426   int result;
73427
73428   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
73429   jresult = (int)result;
73430   return jresult;
73431 }
73432
73433
73434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
73435   int jresult ;
73436   int result;
73437
73438   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
73439   jresult = (int)result;
73440   return jresult;
73441 }
73442
73443
73444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
73445   int jresult ;
73446   int result;
73447
73448   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
73449   jresult = (int)result;
73450   return jresult;
73451 }
73452
73453
73454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
73455   int jresult ;
73456   int result;
73457
73458   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
73459   jresult = (int)result;
73460   return jresult;
73461 }
73462
73463
73464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
73465   int jresult ;
73466   int result;
73467
73468   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
73469   jresult = (int)result;
73470   return jresult;
73471 }
73472
73473
73474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
73475   void * jresult ;
73476   Dali::Toolkit::ScrollView::Property *result = 0 ;
73477
73478   {
73479     try {
73480       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
73481     } catch (std::out_of_range& e) {
73482       {
73483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73484       };
73485     } catch (std::exception& e) {
73486       {
73487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73488       };
73489     } catch (...) {
73490       {
73491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73492       };
73493     }
73494   }
73495   jresult = (void *)result;
73496   return jresult;
73497 }
73498
73499
73500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
73501   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
73502
73503   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
73504   {
73505     try {
73506       delete arg1;
73507     } catch (std::out_of_range& e) {
73508       {
73509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73510       };
73511     } catch (std::exception& e) {
73512       {
73513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73514       };
73515     } catch (...) {
73516       {
73517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73518       };
73519     }
73520   }
73521 }
73522
73523
73524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
73525   void * jresult ;
73526   Dali::Toolkit::ScrollView *result = 0 ;
73527
73528   {
73529     try {
73530       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
73531     } catch (std::out_of_range& e) {
73532       {
73533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73534       };
73535     } catch (std::exception& e) {
73536       {
73537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73538       };
73539     } catch (...) {
73540       {
73541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73542       };
73543     }
73544   }
73545   jresult = (void *)result;
73546   return jresult;
73547 }
73548
73549
73550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
73551   void * jresult ;
73552   Dali::Toolkit::ScrollView *arg1 = 0 ;
73553   Dali::Toolkit::ScrollView *result = 0 ;
73554
73555   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73556   if (!arg1) {
73557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
73558     return 0;
73559   }
73560   {
73561     try {
73562       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
73563     } catch (std::out_of_range& e) {
73564       {
73565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73566       };
73567     } catch (std::exception& e) {
73568       {
73569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73570       };
73571     } catch (...) {
73572       {
73573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73574       };
73575     }
73576   }
73577   jresult = (void *)result;
73578   return jresult;
73579 }
73580
73581
73582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
73583   void * jresult ;
73584   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73585   Dali::Toolkit::ScrollView *arg2 = 0 ;
73586   Dali::Toolkit::ScrollView *result = 0 ;
73587
73588   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73589   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
73590   if (!arg2) {
73591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
73592     return 0;
73593   }
73594   {
73595     try {
73596       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
73597     } catch (std::out_of_range& e) {
73598       {
73599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73600       };
73601     } catch (std::exception& e) {
73602       {
73603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73604       };
73605     } catch (...) {
73606       {
73607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73608       };
73609     }
73610   }
73611   jresult = (void *)result;
73612   return jresult;
73613 }
73614
73615
73616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
73617   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73618
73619   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73620   {
73621     try {
73622       delete arg1;
73623     } catch (std::out_of_range& e) {
73624       {
73625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73626       };
73627     } catch (std::exception& e) {
73628       {
73629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73630       };
73631     } catch (...) {
73632       {
73633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73634       };
73635     }
73636   }
73637 }
73638
73639
73640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
73641   void * jresult ;
73642   Dali::Toolkit::ScrollView result;
73643
73644   {
73645     try {
73646       result = Dali::Toolkit::ScrollView::New();
73647     } catch (std::out_of_range& e) {
73648       {
73649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73650       };
73651     } catch (std::exception& e) {
73652       {
73653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73654       };
73655     } catch (...) {
73656       {
73657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73658       };
73659     }
73660   }
73661   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
73662   return jresult;
73663 }
73664
73665
73666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
73667   void * jresult ;
73668   Dali::BaseHandle arg1 ;
73669   Dali::BaseHandle *argp1 ;
73670   Dali::Toolkit::ScrollView result;
73671
73672   argp1 = (Dali::BaseHandle *)jarg1;
73673   if (!argp1) {
73674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73675     return 0;
73676   }
73677   arg1 = *argp1;
73678   {
73679     try {
73680       result = Dali::Toolkit::ScrollView::DownCast(arg1);
73681     } catch (std::out_of_range& e) {
73682       {
73683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73684       };
73685     } catch (std::exception& e) {
73686       {
73687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73688       };
73689     } catch (...) {
73690       {
73691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73692       };
73693     }
73694   }
73695   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
73696   return jresult;
73697 }
73698
73699
73700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
73701   void * jresult ;
73702   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73703   Dali::AlphaFunction result;
73704
73705   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73706   {
73707     try {
73708       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
73709     } catch (std::out_of_range& e) {
73710       {
73711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73712       };
73713     } catch (std::exception& e) {
73714       {
73715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73716       };
73717     } catch (...) {
73718       {
73719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73720       };
73721     }
73722   }
73723   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
73724   return jresult;
73725 }
73726
73727
73728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
73729   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73730   Dali::AlphaFunction arg2 ;
73731   Dali::AlphaFunction *argp2 ;
73732
73733   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73734   argp2 = (Dali::AlphaFunction *)jarg2;
73735   if (!argp2) {
73736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
73737     return ;
73738   }
73739   arg2 = *argp2;
73740   {
73741     try {
73742       (arg1)->SetScrollSnapAlphaFunction(arg2);
73743     } catch (std::out_of_range& e) {
73744       {
73745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73746       };
73747     } catch (std::exception& e) {
73748       {
73749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73750       };
73751     } catch (...) {
73752       {
73753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73754       };
73755     }
73756   }
73757 }
73758
73759
73760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
73761   void * jresult ;
73762   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73763   Dali::AlphaFunction result;
73764
73765   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73766   {
73767     try {
73768       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
73769     } catch (std::out_of_range& e) {
73770       {
73771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73772       };
73773     } catch (std::exception& e) {
73774       {
73775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73776       };
73777     } catch (...) {
73778       {
73779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73780       };
73781     }
73782   }
73783   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
73784   return jresult;
73785 }
73786
73787
73788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
73789   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73790   Dali::AlphaFunction arg2 ;
73791   Dali::AlphaFunction *argp2 ;
73792
73793   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73794   argp2 = (Dali::AlphaFunction *)jarg2;
73795   if (!argp2) {
73796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
73797     return ;
73798   }
73799   arg2 = *argp2;
73800   {
73801     try {
73802       (arg1)->SetScrollFlickAlphaFunction(arg2);
73803     } catch (std::out_of_range& e) {
73804       {
73805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73806       };
73807     } catch (std::exception& e) {
73808       {
73809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73810       };
73811     } catch (...) {
73812       {
73813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73814       };
73815     }
73816   }
73817 }
73818
73819
73820 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
73821   float jresult ;
73822   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73823   float result;
73824
73825   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73826   {
73827     try {
73828       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
73829     } catch (std::out_of_range& e) {
73830       {
73831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73832       };
73833     } catch (std::exception& e) {
73834       {
73835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73836       };
73837     } catch (...) {
73838       {
73839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73840       };
73841     }
73842   }
73843   jresult = result;
73844   return jresult;
73845 }
73846
73847
73848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
73849   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73850   float arg2 ;
73851
73852   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73853   arg2 = (float)jarg2;
73854   {
73855     try {
73856       (arg1)->SetScrollSnapDuration(arg2);
73857     } catch (std::out_of_range& e) {
73858       {
73859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73860       };
73861     } catch (std::exception& e) {
73862       {
73863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73864       };
73865     } catch (...) {
73866       {
73867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73868       };
73869     }
73870   }
73871 }
73872
73873
73874 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
73875   float jresult ;
73876   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73877   float result;
73878
73879   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73880   {
73881     try {
73882       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
73883     } catch (std::out_of_range& e) {
73884       {
73885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73886       };
73887     } catch (std::exception& e) {
73888       {
73889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73890       };
73891     } catch (...) {
73892       {
73893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73894       };
73895     }
73896   }
73897   jresult = result;
73898   return jresult;
73899 }
73900
73901
73902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
73903   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73904   float arg2 ;
73905
73906   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73907   arg2 = (float)jarg2;
73908   {
73909     try {
73910       (arg1)->SetScrollFlickDuration(arg2);
73911     } catch (std::out_of_range& e) {
73912       {
73913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73914       };
73915     } catch (std::exception& e) {
73916       {
73917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73918       };
73919     } catch (...) {
73920       {
73921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73922       };
73923     }
73924   }
73925 }
73926
73927
73928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
73929   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73930   Dali::Toolkit::RulerPtr arg2 ;
73931   Dali::Toolkit::RulerPtr *argp2 ;
73932
73933   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73934   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
73935   if (!argp2) {
73936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
73937     return ;
73938   }
73939   arg2 = *argp2;
73940   {
73941     try {
73942       (arg1)->SetRulerX(arg2);
73943     } catch (std::out_of_range& e) {
73944       {
73945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73946       };
73947     } catch (std::exception& e) {
73948       {
73949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73950       };
73951     } catch (...) {
73952       {
73953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73954       };
73955     }
73956   }
73957 }
73958
73959
73960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
73961   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73962   Dali::Toolkit::RulerPtr arg2 ;
73963   Dali::Toolkit::RulerPtr *argp2 ;
73964
73965   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73966   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
73967   if (!argp2) {
73968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
73969     return ;
73970   }
73971   arg2 = *argp2;
73972   {
73973     try {
73974       (arg1)->SetRulerY(arg2);
73975     } catch (std::out_of_range& e) {
73976       {
73977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73978       };
73979     } catch (std::exception& e) {
73980       {
73981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73982       };
73983     } catch (...) {
73984       {
73985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73986       };
73987     }
73988   }
73989 }
73990
73991
73992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
73993   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73994   bool arg2 ;
73995
73996   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73997   arg2 = jarg2 ? true : false;
73998   {
73999     try {
74000       (arg1)->SetScrollSensitive(arg2);
74001     } catch (std::out_of_range& e) {
74002       {
74003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74004       };
74005     } catch (std::exception& e) {
74006       {
74007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74008       };
74009     } catch (...) {
74010       {
74011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74012       };
74013     }
74014   }
74015 }
74016
74017
74018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
74019   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74020   float arg2 ;
74021   float arg3 ;
74022
74023   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74024   arg2 = (float)jarg2;
74025   arg3 = (float)jarg3;
74026   {
74027     try {
74028       (arg1)->SetMaxOvershoot(arg2,arg3);
74029     } catch (std::out_of_range& e) {
74030       {
74031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74032       };
74033     } catch (std::exception& e) {
74034       {
74035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74036       };
74037     } catch (...) {
74038       {
74039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74040       };
74041     }
74042   }
74043 }
74044
74045
74046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
74047   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74048   Dali::AlphaFunction arg2 ;
74049   Dali::AlphaFunction *argp2 ;
74050
74051   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74052   argp2 = (Dali::AlphaFunction *)jarg2;
74053   if (!argp2) {
74054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74055     return ;
74056   }
74057   arg2 = *argp2;
74058   {
74059     try {
74060       (arg1)->SetSnapOvershootAlphaFunction(arg2);
74061     } catch (std::out_of_range& e) {
74062       {
74063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74064       };
74065     } catch (std::exception& e) {
74066       {
74067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74068       };
74069     } catch (...) {
74070       {
74071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74072       };
74073     }
74074   }
74075 }
74076
74077
74078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(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)->SetSnapOvershootDuration(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 void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
74105   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74106   bool arg2 ;
74107
74108   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74109   arg2 = jarg2 ? true : false;
74110   {
74111     try {
74112       (arg1)->SetActorAutoSnap(arg2);
74113     } catch (std::out_of_range& e) {
74114       {
74115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74116       };
74117     } catch (std::exception& e) {
74118       {
74119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74120       };
74121     } catch (...) {
74122       {
74123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74124       };
74125     }
74126   }
74127 }
74128
74129
74130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
74131   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74132   bool arg2 ;
74133
74134   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74135   arg2 = jarg2 ? true : false;
74136   {
74137     try {
74138       (arg1)->SetWrapMode(arg2);
74139     } catch (std::out_of_range& e) {
74140       {
74141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74142       };
74143     } catch (std::exception& e) {
74144       {
74145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74146       };
74147     } catch (...) {
74148       {
74149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74150       };
74151     }
74152   }
74153 }
74154
74155
74156 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
74157   int jresult ;
74158   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74159   int result;
74160
74161   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74162   {
74163     try {
74164       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
74165     } catch (std::out_of_range& e) {
74166       {
74167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74168       };
74169     } catch (std::exception& e) {
74170       {
74171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74172       };
74173     } catch (...) {
74174       {
74175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74176       };
74177     }
74178   }
74179   jresult = result;
74180   return jresult;
74181 }
74182
74183
74184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
74185   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74186   int arg2 ;
74187
74188   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74189   arg2 = (int)jarg2;
74190   {
74191     try {
74192       (arg1)->SetScrollUpdateDistance(arg2);
74193     } catch (std::out_of_range& e) {
74194       {
74195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74196       };
74197     } catch (std::exception& e) {
74198       {
74199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74200       };
74201     } catch (...) {
74202       {
74203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74204       };
74205     }
74206   }
74207 }
74208
74209
74210 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
74211   unsigned int jresult ;
74212   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74213   bool result;
74214
74215   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74216   {
74217     try {
74218       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
74219     } catch (std::out_of_range& e) {
74220       {
74221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74222       };
74223     } catch (std::exception& e) {
74224       {
74225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74226       };
74227     } catch (...) {
74228       {
74229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74230       };
74231     }
74232   }
74233   jresult = result;
74234   return jresult;
74235 }
74236
74237
74238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
74239   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74240   bool arg2 ;
74241
74242   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74243   arg2 = jarg2 ? true : false;
74244   {
74245     try {
74246       (arg1)->SetAxisAutoLock(arg2);
74247     } catch (std::out_of_range& e) {
74248       {
74249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74250       };
74251     } catch (std::exception& e) {
74252       {
74253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74254       };
74255     } catch (...) {
74256       {
74257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74258       };
74259     }
74260   }
74261 }
74262
74263
74264 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
74265   float jresult ;
74266   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74267   float result;
74268
74269   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74270   {
74271     try {
74272       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
74273     } catch (std::out_of_range& e) {
74274       {
74275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74276       };
74277     } catch (std::exception& e) {
74278       {
74279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74280       };
74281     } catch (...) {
74282       {
74283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74284       };
74285     }
74286   }
74287   jresult = result;
74288   return jresult;
74289 }
74290
74291
74292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
74293   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74294   float arg2 ;
74295
74296   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74297   arg2 = (float)jarg2;
74298   {
74299     try {
74300       (arg1)->SetAxisAutoLockGradient(arg2);
74301     } catch (std::out_of_range& e) {
74302       {
74303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74304       };
74305     } catch (std::exception& e) {
74306       {
74307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74308       };
74309     } catch (...) {
74310       {
74311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74312       };
74313     }
74314   }
74315 }
74316
74317
74318 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
74319   float jresult ;
74320   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74321   float result;
74322
74323   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74324   {
74325     try {
74326       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
74327     } catch (std::out_of_range& e) {
74328       {
74329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74330       };
74331     } catch (std::exception& e) {
74332       {
74333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74334       };
74335     } catch (...) {
74336       {
74337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74338       };
74339     }
74340   }
74341   jresult = result;
74342   return jresult;
74343 }
74344
74345
74346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
74347   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74348   float arg2 ;
74349
74350   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74351   arg2 = (float)jarg2;
74352   {
74353     try {
74354       (arg1)->SetFrictionCoefficient(arg2);
74355     } catch (std::out_of_range& e) {
74356       {
74357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74358       };
74359     } catch (std::exception& e) {
74360       {
74361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74362       };
74363     } catch (...) {
74364       {
74365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74366       };
74367     }
74368   }
74369 }
74370
74371
74372 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
74373   float jresult ;
74374   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74375   float result;
74376
74377   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74378   {
74379     try {
74380       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
74381     } catch (std::out_of_range& e) {
74382       {
74383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74384       };
74385     } catch (std::exception& e) {
74386       {
74387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74388       };
74389     } catch (...) {
74390       {
74391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74392       };
74393     }
74394   }
74395   jresult = result;
74396   return jresult;
74397 }
74398
74399
74400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
74401   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74402   float arg2 ;
74403
74404   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74405   arg2 = (float)jarg2;
74406   {
74407     try {
74408       (arg1)->SetFlickSpeedCoefficient(arg2);
74409     } catch (std::out_of_range& e) {
74410       {
74411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74412       };
74413     } catch (std::exception& e) {
74414       {
74415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74416       };
74417     } catch (...) {
74418       {
74419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74420       };
74421     }
74422   }
74423 }
74424
74425
74426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
74427   void * jresult ;
74428   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74429   Dali::Vector2 result;
74430
74431   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74432   {
74433     try {
74434       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
74435     } catch (std::out_of_range& e) {
74436       {
74437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74438       };
74439     } catch (std::exception& e) {
74440       {
74441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74442       };
74443     } catch (...) {
74444       {
74445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74446       };
74447     }
74448   }
74449   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
74450   return jresult;
74451 }
74452
74453
74454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
74455   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74456   Dali::Vector2 *arg2 = 0 ;
74457
74458   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74459   arg2 = (Dali::Vector2 *)jarg2;
74460   if (!arg2) {
74461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74462     return ;
74463   }
74464   {
74465     try {
74466       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
74467     } catch (std::out_of_range& e) {
74468       {
74469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74470       };
74471     } catch (std::exception& e) {
74472       {
74473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74474       };
74475     } catch (...) {
74476       {
74477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74478       };
74479     }
74480   }
74481 }
74482
74483
74484 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
74485   float jresult ;
74486   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74487   float result;
74488
74489   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74490   {
74491     try {
74492       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
74493     } catch (std::out_of_range& e) {
74494       {
74495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74496       };
74497     } catch (std::exception& e) {
74498       {
74499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74500       };
74501     } catch (...) {
74502       {
74503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74504       };
74505     }
74506   }
74507   jresult = result;
74508   return jresult;
74509 }
74510
74511
74512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
74513   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74514   float arg2 ;
74515
74516   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74517   arg2 = (float)jarg2;
74518   {
74519     try {
74520       (arg1)->SetMinimumSpeedForFlick(arg2);
74521     } catch (std::out_of_range& e) {
74522       {
74523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74524       };
74525     } catch (std::exception& e) {
74526       {
74527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74528       };
74529     } catch (...) {
74530       {
74531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74532       };
74533     }
74534   }
74535 }
74536
74537
74538 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
74539   float jresult ;
74540   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74541   float result;
74542
74543   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74544   {
74545     try {
74546       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
74547     } catch (std::out_of_range& e) {
74548       {
74549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74550       };
74551     } catch (std::exception& e) {
74552       {
74553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74554       };
74555     } catch (...) {
74556       {
74557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74558       };
74559     }
74560   }
74561   jresult = result;
74562   return jresult;
74563 }
74564
74565
74566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
74567   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74568   float arg2 ;
74569
74570   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74571   arg2 = (float)jarg2;
74572   {
74573     try {
74574       (arg1)->SetMaxFlickSpeed(arg2);
74575     } catch (std::out_of_range& e) {
74576       {
74577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74578       };
74579     } catch (std::exception& e) {
74580       {
74581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74582       };
74583     } catch (...) {
74584       {
74585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74586       };
74587     }
74588   }
74589 }
74590
74591
74592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
74593   void * jresult ;
74594   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74595   Dali::Vector2 result;
74596
74597   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74598   {
74599     try {
74600       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
74601     } catch (std::out_of_range& e) {
74602       {
74603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74604       };
74605     } catch (std::exception& e) {
74606       {
74607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74608       };
74609     } catch (...) {
74610       {
74611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74612       };
74613     }
74614   }
74615   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
74616   return jresult;
74617 }
74618
74619
74620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
74621   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74622   Dali::Vector2 arg2 ;
74623   Dali::Vector2 *argp2 ;
74624
74625   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74626   argp2 = (Dali::Vector2 *)jarg2;
74627   if (!argp2) {
74628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
74629     return ;
74630   }
74631   arg2 = *argp2;
74632   {
74633     try {
74634       (arg1)->SetWheelScrollDistanceStep(arg2);
74635     } catch (std::out_of_range& e) {
74636       {
74637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74638       };
74639     } catch (std::exception& e) {
74640       {
74641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74642       };
74643     } catch (...) {
74644       {
74645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74646       };
74647     }
74648   }
74649 }
74650
74651
74652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
74653   void * jresult ;
74654   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74655   Dali::Vector2 result;
74656
74657   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74658   {
74659     try {
74660       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
74661     } catch (std::out_of_range& e) {
74662       {
74663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74664       };
74665     } catch (std::exception& e) {
74666       {
74667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74668       };
74669     } catch (...) {
74670       {
74671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74672       };
74673     }
74674   }
74675   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
74676   return jresult;
74677 }
74678
74679
74680 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
74681   unsigned int jresult ;
74682   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74683   unsigned int result;
74684
74685   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74686   {
74687     try {
74688       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
74689     } catch (std::out_of_range& e) {
74690       {
74691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74692       };
74693     } catch (std::exception& e) {
74694       {
74695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74696       };
74697     } catch (...) {
74698       {
74699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74700       };
74701     }
74702   }
74703   jresult = result;
74704   return jresult;
74705 }
74706
74707
74708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
74709   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74710   Dali::Vector2 *arg2 = 0 ;
74711
74712   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74713   arg2 = (Dali::Vector2 *)jarg2;
74714   if (!arg2) {
74715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74716     return ;
74717   }
74718   {
74719     try {
74720       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
74721     } catch (std::out_of_range& e) {
74722       {
74723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74724       };
74725     } catch (std::exception& e) {
74726       {
74727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74728       };
74729     } catch (...) {
74730       {
74731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74732       };
74733     }
74734   }
74735 }
74736
74737
74738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
74739   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74740   Dali::Vector2 *arg2 = 0 ;
74741   float arg3 ;
74742
74743   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74744   arg2 = (Dali::Vector2 *)jarg2;
74745   if (!arg2) {
74746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74747     return ;
74748   }
74749   arg3 = (float)jarg3;
74750   {
74751     try {
74752       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
74753     } catch (std::out_of_range& e) {
74754       {
74755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74756       };
74757     } catch (std::exception& e) {
74758       {
74759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74760       };
74761     } catch (...) {
74762       {
74763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74764       };
74765     }
74766   }
74767 }
74768
74769
74770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
74771   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74772   Dali::Vector2 *arg2 = 0 ;
74773   float arg3 ;
74774   Dali::AlphaFunction arg4 ;
74775   Dali::AlphaFunction *argp4 ;
74776
74777   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74778   arg2 = (Dali::Vector2 *)jarg2;
74779   if (!arg2) {
74780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74781     return ;
74782   }
74783   arg3 = (float)jarg3;
74784   argp4 = (Dali::AlphaFunction *)jarg4;
74785   if (!argp4) {
74786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74787     return ;
74788   }
74789   arg4 = *argp4;
74790   {
74791     try {
74792       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
74793     } catch (std::out_of_range& e) {
74794       {
74795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74796       };
74797     } catch (std::exception& e) {
74798       {
74799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74800       };
74801     } catch (...) {
74802       {
74803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74804       };
74805     }
74806   }
74807 }
74808
74809
74810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
74811   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74812   Dali::Vector2 *arg2 = 0 ;
74813   float arg3 ;
74814   Dali::Toolkit::DirectionBias arg4 ;
74815   Dali::Toolkit::DirectionBias arg5 ;
74816
74817   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74818   arg2 = (Dali::Vector2 *)jarg2;
74819   if (!arg2) {
74820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74821     return ;
74822   }
74823   arg3 = (float)jarg3;
74824   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
74825   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
74826   {
74827     try {
74828       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
74829     } catch (std::out_of_range& e) {
74830       {
74831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74832       };
74833     } catch (std::exception& e) {
74834       {
74835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74836       };
74837     } catch (...) {
74838       {
74839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74840       };
74841     }
74842   }
74843 }
74844
74845
74846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
74847   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74848   Dali::Vector2 *arg2 = 0 ;
74849   float arg3 ;
74850   Dali::AlphaFunction arg4 ;
74851   Dali::Toolkit::DirectionBias arg5 ;
74852   Dali::Toolkit::DirectionBias arg6 ;
74853   Dali::AlphaFunction *argp4 ;
74854
74855   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74856   arg2 = (Dali::Vector2 *)jarg2;
74857   if (!arg2) {
74858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74859     return ;
74860   }
74861   arg3 = (float)jarg3;
74862   argp4 = (Dali::AlphaFunction *)jarg4;
74863   if (!argp4) {
74864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74865     return ;
74866   }
74867   arg4 = *argp4;
74868   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
74869   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
74870   {
74871     try {
74872       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
74873     } catch (std::out_of_range& e) {
74874       {
74875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74876       };
74877     } catch (std::exception& e) {
74878       {
74879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74880       };
74881     } catch (...) {
74882       {
74883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74884       };
74885     }
74886   }
74887 }
74888
74889
74890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
74891   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74892   unsigned int arg2 ;
74893
74894   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74895   arg2 = (unsigned int)jarg2;
74896   {
74897     try {
74898       (arg1)->ScrollTo(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_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
74917   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74918   unsigned int arg2 ;
74919   float arg3 ;
74920
74921   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74922   arg2 = (unsigned int)jarg2;
74923   arg3 = (float)jarg3;
74924   {
74925     try {
74926       (arg1)->ScrollTo(arg2,arg3);
74927     } catch (std::out_of_range& e) {
74928       {
74929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74930       };
74931     } catch (std::exception& e) {
74932       {
74933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74934       };
74935     } catch (...) {
74936       {
74937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74938       };
74939     }
74940   }
74941 }
74942
74943
74944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
74945   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74946   unsigned int arg2 ;
74947   float arg3 ;
74948   Dali::Toolkit::DirectionBias arg4 ;
74949
74950   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74951   arg2 = (unsigned int)jarg2;
74952   arg3 = (float)jarg3;
74953   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
74954   {
74955     try {
74956       (arg1)->ScrollTo(arg2,arg3,arg4);
74957     } catch (std::out_of_range& e) {
74958       {
74959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74960       };
74961     } catch (std::exception& e) {
74962       {
74963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74964       };
74965     } catch (...) {
74966       {
74967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74968       };
74969     }
74970   }
74971 }
74972
74973
74974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
74975   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74976   Dali::Actor *arg2 = 0 ;
74977
74978   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74979   arg2 = (Dali::Actor *)jarg2;
74980   if (!arg2) {
74981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
74982     return ;
74983   }
74984   {
74985     try {
74986       (arg1)->ScrollTo(*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_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
75005   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75006   Dali::Actor *arg2 = 0 ;
75007   float arg3 ;
75008
75009   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75010   arg2 = (Dali::Actor *)jarg2;
75011   if (!arg2) {
75012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75013     return ;
75014   }
75015   arg3 = (float)jarg3;
75016   {
75017     try {
75018       (arg1)->ScrollTo(*arg2,arg3);
75019     } catch (std::out_of_range& e) {
75020       {
75021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75022       };
75023     } catch (std::exception& e) {
75024       {
75025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75026       };
75027     } catch (...) {
75028       {
75029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75030       };
75031     }
75032   }
75033 }
75034
75035
75036 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
75037   unsigned int jresult ;
75038   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75039   bool result;
75040
75041   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75042   {
75043     try {
75044       result = (bool)(arg1)->ScrollToSnapPoint();
75045     } catch (std::out_of_range& e) {
75046       {
75047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75048       };
75049     } catch (std::exception& e) {
75050       {
75051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75052       };
75053     } catch (...) {
75054       {
75055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75056       };
75057     }
75058   }
75059   jresult = result;
75060   return jresult;
75061 }
75062
75063
75064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
75065   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75066   Dali::Constraint arg2 ;
75067   Dali::Constraint *argp2 ;
75068
75069   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75070   argp2 = (Dali::Constraint *)jarg2;
75071   if (!argp2) {
75072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
75073     return ;
75074   }
75075   arg2 = *argp2;
75076   {
75077     try {
75078       (arg1)->ApplyConstraintToChildren(arg2);
75079     } catch (std::out_of_range& e) {
75080       {
75081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75082       };
75083     } catch (std::exception& e) {
75084       {
75085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75086       };
75087     } catch (...) {
75088       {
75089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75090       };
75091     }
75092   }
75093 }
75094
75095
75096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
75097   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75098
75099   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75100   {
75101     try {
75102       (arg1)->RemoveConstraintsFromChildren();
75103     } catch (std::out_of_range& e) {
75104       {
75105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75106       };
75107     } catch (std::exception& e) {
75108       {
75109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75110       };
75111     } catch (...) {
75112       {
75113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75114       };
75115     }
75116   }
75117 }
75118
75119
75120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
75121   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75122   Dali::Toolkit::ScrollViewEffect arg2 ;
75123   Dali::Toolkit::ScrollViewEffect *argp2 ;
75124
75125   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75126   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
75127   if (!argp2) {
75128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
75129     return ;
75130   }
75131   arg2 = *argp2;
75132   {
75133     try {
75134       (arg1)->ApplyEffect(arg2);
75135     } catch (std::out_of_range& e) {
75136       {
75137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75138       };
75139     } catch (std::exception& e) {
75140       {
75141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75142       };
75143     } catch (...) {
75144       {
75145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75146       };
75147     }
75148   }
75149 }
75150
75151
75152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
75153   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75154   Dali::Toolkit::ScrollViewEffect arg2 ;
75155   Dali::Toolkit::ScrollViewEffect *argp2 ;
75156
75157   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75158   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
75159   if (!argp2) {
75160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
75161     return ;
75162   }
75163   arg2 = *argp2;
75164   {
75165     try {
75166       (arg1)->RemoveEffect(arg2);
75167     } catch (std::out_of_range& e) {
75168       {
75169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75170       };
75171     } catch (std::exception& e) {
75172       {
75173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75174       };
75175     } catch (...) {
75176       {
75177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75178       };
75179     }
75180   }
75181 }
75182
75183
75184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
75185   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75186
75187   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75188   {
75189     try {
75190       (arg1)->RemoveAllEffects();
75191     } catch (std::out_of_range& e) {
75192       {
75193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75194       };
75195     } catch (std::exception& e) {
75196       {
75197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75198       };
75199     } catch (...) {
75200       {
75201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75202       };
75203     }
75204   }
75205 }
75206
75207
75208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
75209   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75210   Dali::Actor arg2 ;
75211   Dali::Actor *argp2 ;
75212
75213   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75214   argp2 = (Dali::Actor *)jarg2;
75215   if (!argp2) {
75216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75217     return ;
75218   }
75219   arg2 = *argp2;
75220   {
75221     try {
75222       (arg1)->BindActor(arg2);
75223     } catch (std::out_of_range& e) {
75224       {
75225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75226       };
75227     } catch (std::exception& e) {
75228       {
75229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75230       };
75231     } catch (...) {
75232       {
75233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75234       };
75235     }
75236   }
75237 }
75238
75239
75240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
75241   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75242   Dali::Actor arg2 ;
75243   Dali::Actor *argp2 ;
75244
75245   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75246   argp2 = (Dali::Actor *)jarg2;
75247   if (!argp2) {
75248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75249     return ;
75250   }
75251   arg2 = *argp2;
75252   {
75253     try {
75254       (arg1)->UnbindActor(arg2);
75255     } catch (std::out_of_range& e) {
75256       {
75257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75258       };
75259     } catch (std::exception& e) {
75260       {
75261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75262       };
75263     } catch (...) {
75264       {
75265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75266       };
75267     }
75268   }
75269 }
75270
75271
75272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
75273   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75274   Dali::Radian arg2 ;
75275   Dali::Radian arg3 ;
75276   Dali::Radian *argp2 ;
75277   Dali::Radian *argp3 ;
75278
75279   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75280   argp2 = (Dali::Radian *)jarg2;
75281   if (!argp2) {
75282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
75283     return ;
75284   }
75285   arg2 = *argp2;
75286   argp3 = (Dali::Radian *)jarg3;
75287   if (!argp3) {
75288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
75289     return ;
75290   }
75291   arg3 = *argp3;
75292   {
75293     try {
75294       (arg1)->SetScrollingDirection(arg2,arg3);
75295     } catch (std::out_of_range& e) {
75296       {
75297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75298       };
75299     } catch (std::exception& e) {
75300       {
75301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75302       };
75303     } catch (...) {
75304       {
75305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75306       };
75307     }
75308   }
75309 }
75310
75311
75312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
75313   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75314   Dali::Radian arg2 ;
75315   Dali::Radian *argp2 ;
75316
75317   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75318   argp2 = (Dali::Radian *)jarg2;
75319   if (!argp2) {
75320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
75321     return ;
75322   }
75323   arg2 = *argp2;
75324   {
75325     try {
75326       (arg1)->SetScrollingDirection(arg2);
75327     } catch (std::out_of_range& e) {
75328       {
75329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75330       };
75331     } catch (std::exception& e) {
75332       {
75333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75334       };
75335     } catch (...) {
75336       {
75337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75338       };
75339     }
75340   }
75341 }
75342
75343
75344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
75345   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75346   Dali::Radian arg2 ;
75347   Dali::Radian *argp2 ;
75348
75349   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75350   argp2 = (Dali::Radian *)jarg2;
75351   if (!argp2) {
75352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
75353     return ;
75354   }
75355   arg2 = *argp2;
75356   {
75357     try {
75358       (arg1)->RemoveScrollingDirection(arg2);
75359     } catch (std::out_of_range& e) {
75360       {
75361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75362       };
75363     } catch (std::exception& e) {
75364       {
75365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75366       };
75367     } catch (...) {
75368       {
75369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75370       };
75371     }
75372   }
75373 }
75374
75375
75376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
75377   void * jresult ;
75378   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75379   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
75380
75381   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75382   {
75383     try {
75384       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
75385     } catch (std::out_of_range& e) {
75386       {
75387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75388       };
75389     } catch (std::exception& e) {
75390       {
75391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75392       };
75393     } catch (...) {
75394       {
75395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75396       };
75397     }
75398   }
75399   jresult = (void *)result;
75400   return jresult;
75401 }
75402
75403
75404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
75405   int jresult ;
75406   int result;
75407
75408   result = (int)Dali::Toolkit::TableView::Property::ROWS;
75409   jresult = (int)result;
75410   return jresult;
75411 }
75412
75413
75414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
75415   int jresult ;
75416   int result;
75417
75418   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
75419   jresult = (int)result;
75420   return jresult;
75421 }
75422
75423
75424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
75425   int jresult ;
75426   int result;
75427
75428   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
75429   jresult = (int)result;
75430   return jresult;
75431 }
75432
75433
75434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
75435   int jresult ;
75436   int result;
75437
75438   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
75439   jresult = (int)result;
75440   return jresult;
75441 }
75442
75443
75444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
75445   int jresult ;
75446   int result;
75447
75448   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
75449   jresult = (int)result;
75450   return jresult;
75451 }
75452
75453
75454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
75455   void * jresult ;
75456   Dali::Toolkit::TableView::Property *result = 0 ;
75457
75458   {
75459     try {
75460       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
75461     } catch (std::out_of_range& e) {
75462       {
75463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75464       };
75465     } catch (std::exception& e) {
75466       {
75467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75468       };
75469     } catch (...) {
75470       {
75471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75472       };
75473     }
75474   }
75475   jresult = (void *)result;
75476   return jresult;
75477 }
75478
75479
75480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
75481   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
75482
75483   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
75484   {
75485     try {
75486       delete arg1;
75487     } catch (std::out_of_range& e) {
75488       {
75489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75490       };
75491     } catch (std::exception& e) {
75492       {
75493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75494       };
75495     } catch (...) {
75496       {
75497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75498       };
75499     }
75500   }
75501 }
75502
75503
75504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
75505   int jresult ;
75506   int result;
75507
75508   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
75509   jresult = (int)result;
75510   return jresult;
75511 }
75512
75513
75514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
75515   int jresult ;
75516   int result;
75517
75518   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
75519   jresult = (int)result;
75520   return jresult;
75521 }
75522
75523
75524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
75525   int jresult ;
75526   int result;
75527
75528   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
75529   jresult = (int)result;
75530   return jresult;
75531 }
75532
75533
75534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
75535   int jresult ;
75536   int result;
75537
75538   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
75539   jresult = (int)result;
75540   return jresult;
75541 }
75542
75543
75544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
75545   int jresult ;
75546   int result;
75547
75548   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
75549   jresult = (int)result;
75550   return jresult;
75551 }
75552
75553
75554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
75555   void * jresult ;
75556   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
75557
75558   {
75559     try {
75560       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
75561     } catch (std::out_of_range& e) {
75562       {
75563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75564       };
75565     } catch (std::exception& e) {
75566       {
75567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75568       };
75569     } catch (...) {
75570       {
75571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75572       };
75573     }
75574   }
75575   jresult = (void *)result;
75576   return jresult;
75577 }
75578
75579
75580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
75581   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
75582
75583   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
75584   {
75585     try {
75586       delete arg1;
75587     } catch (std::out_of_range& e) {
75588       {
75589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75590       };
75591     } catch (std::exception& e) {
75592       {
75593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75594       };
75595     } catch (...) {
75596       {
75597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75598       };
75599     }
75600   }
75601 }
75602
75603
75604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
75605   void * jresult ;
75606   unsigned int arg1 ;
75607   unsigned int arg2 ;
75608   unsigned int arg3 ;
75609   unsigned int arg4 ;
75610   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75611
75612   arg1 = (unsigned int)jarg1;
75613   arg2 = (unsigned int)jarg2;
75614   arg3 = (unsigned int)jarg3;
75615   arg4 = (unsigned int)jarg4;
75616   {
75617     try {
75618       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
75619     } catch (std::out_of_range& e) {
75620       {
75621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75622       };
75623     } catch (std::exception& e) {
75624       {
75625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75626       };
75627     } catch (...) {
75628       {
75629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75630       };
75631     }
75632   }
75633   jresult = (void *)result;
75634   return jresult;
75635 }
75636
75637
75638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
75639   void * jresult ;
75640   unsigned int arg1 ;
75641   unsigned int arg2 ;
75642   unsigned int arg3 ;
75643   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75644
75645   arg1 = (unsigned int)jarg1;
75646   arg2 = (unsigned int)jarg2;
75647   arg3 = (unsigned int)jarg3;
75648   {
75649     try {
75650       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
75651     } catch (std::out_of_range& e) {
75652       {
75653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75654       };
75655     } catch (std::exception& e) {
75656       {
75657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75658       };
75659     } catch (...) {
75660       {
75661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75662       };
75663     }
75664   }
75665   jresult = (void *)result;
75666   return jresult;
75667 }
75668
75669
75670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
75671   void * jresult ;
75672   unsigned int arg1 ;
75673   unsigned int arg2 ;
75674   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75675
75676   arg1 = (unsigned int)jarg1;
75677   arg2 = (unsigned int)jarg2;
75678   {
75679     try {
75680       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
75681     } catch (std::out_of_range& e) {
75682       {
75683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75684       };
75685     } catch (std::exception& e) {
75686       {
75687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75688       };
75689     } catch (...) {
75690       {
75691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75692       };
75693     }
75694   }
75695   jresult = (void *)result;
75696   return jresult;
75697 }
75698
75699
75700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
75701   void * jresult ;
75702   unsigned int arg1 ;
75703   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75704
75705   arg1 = (unsigned int)jarg1;
75706   {
75707     try {
75708       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
75709     } catch (std::out_of_range& e) {
75710       {
75711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75712       };
75713     } catch (std::exception& e) {
75714       {
75715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75716       };
75717     } catch (...) {
75718       {
75719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75720       };
75721     }
75722   }
75723   jresult = (void *)result;
75724   return jresult;
75725 }
75726
75727
75728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
75729   void * jresult ;
75730   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75731
75732   {
75733     try {
75734       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
75735     } catch (std::out_of_range& e) {
75736       {
75737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75738       };
75739     } catch (std::exception& e) {
75740       {
75741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75742       };
75743     } catch (...) {
75744       {
75745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75746       };
75747     }
75748   }
75749   jresult = (void *)result;
75750   return jresult;
75751 }
75752
75753
75754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
75755   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75756   unsigned int arg2 ;
75757
75758   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75759   arg2 = (unsigned int)jarg2;
75760   if (arg1) (arg1)->rowIndex = arg2;
75761 }
75762
75763
75764 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
75765   unsigned int jresult ;
75766   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75767   unsigned int result;
75768
75769   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75770   result = (unsigned int) ((arg1)->rowIndex);
75771   jresult = result;
75772   return jresult;
75773 }
75774
75775
75776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
75777   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75778   unsigned int arg2 ;
75779
75780   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75781   arg2 = (unsigned int)jarg2;
75782   if (arg1) (arg1)->columnIndex = arg2;
75783 }
75784
75785
75786 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
75787   unsigned int jresult ;
75788   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75789   unsigned int result;
75790
75791   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75792   result = (unsigned int) ((arg1)->columnIndex);
75793   jresult = result;
75794   return jresult;
75795 }
75796
75797
75798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
75799   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75800   unsigned int arg2 ;
75801
75802   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75803   arg2 = (unsigned int)jarg2;
75804   if (arg1) (arg1)->rowSpan = arg2;
75805 }
75806
75807
75808 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
75809   unsigned int jresult ;
75810   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75811   unsigned int result;
75812
75813   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75814   result = (unsigned int) ((arg1)->rowSpan);
75815   jresult = result;
75816   return jresult;
75817 }
75818
75819
75820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
75821   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75822   unsigned int arg2 ;
75823
75824   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75825   arg2 = (unsigned int)jarg2;
75826   if (arg1) (arg1)->columnSpan = arg2;
75827 }
75828
75829
75830 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
75831   unsigned int jresult ;
75832   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75833   unsigned int result;
75834
75835   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75836   result = (unsigned int) ((arg1)->columnSpan);
75837   jresult = result;
75838   return jresult;
75839 }
75840
75841
75842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
75843   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75844
75845   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75846   {
75847     try {
75848       delete arg1;
75849     } catch (std::out_of_range& e) {
75850       {
75851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75852       };
75853     } catch (std::exception& e) {
75854       {
75855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75856       };
75857     } catch (...) {
75858       {
75859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75860       };
75861     }
75862   }
75863 }
75864
75865
75866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
75867   void * jresult ;
75868   Dali::Toolkit::TableView *result = 0 ;
75869
75870   {
75871     try {
75872       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
75873     } catch (std::out_of_range& e) {
75874       {
75875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75876       };
75877     } catch (std::exception& e) {
75878       {
75879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75880       };
75881     } catch (...) {
75882       {
75883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75884       };
75885     }
75886   }
75887   jresult = (void *)result;
75888   return jresult;
75889 }
75890
75891
75892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
75893   void * jresult ;
75894   Dali::Toolkit::TableView *arg1 = 0 ;
75895   Dali::Toolkit::TableView *result = 0 ;
75896
75897   arg1 = (Dali::Toolkit::TableView *)jarg1;
75898   if (!arg1) {
75899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
75900     return 0;
75901   }
75902   {
75903     try {
75904       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
75905     } catch (std::out_of_range& e) {
75906       {
75907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75908       };
75909     } catch (std::exception& e) {
75910       {
75911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75912       };
75913     } catch (...) {
75914       {
75915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75916       };
75917     }
75918   }
75919   jresult = (void *)result;
75920   return jresult;
75921 }
75922
75923
75924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
75925   void * jresult ;
75926   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75927   Dali::Toolkit::TableView *arg2 = 0 ;
75928   Dali::Toolkit::TableView *result = 0 ;
75929
75930   arg1 = (Dali::Toolkit::TableView *)jarg1;
75931   arg2 = (Dali::Toolkit::TableView *)jarg2;
75932   if (!arg2) {
75933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
75934     return 0;
75935   }
75936   {
75937     try {
75938       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
75939     } catch (std::out_of_range& e) {
75940       {
75941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75942       };
75943     } catch (std::exception& e) {
75944       {
75945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75946       };
75947     } catch (...) {
75948       {
75949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75950       };
75951     }
75952   }
75953   jresult = (void *)result;
75954   return jresult;
75955 }
75956
75957
75958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
75959   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75960
75961   arg1 = (Dali::Toolkit::TableView *)jarg1;
75962   {
75963     try {
75964       delete arg1;
75965     } catch (std::out_of_range& e) {
75966       {
75967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75968       };
75969     } catch (std::exception& e) {
75970       {
75971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75972       };
75973     } catch (...) {
75974       {
75975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75976       };
75977     }
75978   }
75979 }
75980
75981
75982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
75983   void * jresult ;
75984   unsigned int arg1 ;
75985   unsigned int arg2 ;
75986   Dali::Toolkit::TableView result;
75987
75988   arg1 = (unsigned int)jarg1;
75989   arg2 = (unsigned int)jarg2;
75990   {
75991     try {
75992       result = Dali::Toolkit::TableView::New(arg1,arg2);
75993     } catch (std::out_of_range& e) {
75994       {
75995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75996       };
75997     } catch (std::exception& e) {
75998       {
75999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76000       };
76001     } catch (...) {
76002       {
76003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76004       };
76005     }
76006   }
76007   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
76008   return jresult;
76009 }
76010
76011
76012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
76013   void * jresult ;
76014   Dali::BaseHandle arg1 ;
76015   Dali::BaseHandle *argp1 ;
76016   Dali::Toolkit::TableView result;
76017
76018   argp1 = (Dali::BaseHandle *)jarg1;
76019   if (!argp1) {
76020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76021     return 0;
76022   }
76023   arg1 = *argp1;
76024   {
76025     try {
76026       result = Dali::Toolkit::TableView::DownCast(arg1);
76027     } catch (std::out_of_range& e) {
76028       {
76029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76030       };
76031     } catch (std::exception& e) {
76032       {
76033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76034       };
76035     } catch (...) {
76036       {
76037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76038       };
76039     }
76040   }
76041   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
76042   return jresult;
76043 }
76044
76045
76046 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
76047   unsigned int jresult ;
76048   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76049   Dali::Actor arg2 ;
76050   Dali::Toolkit::TableView::CellPosition arg3 ;
76051   Dali::Actor *argp2 ;
76052   Dali::Toolkit::TableView::CellPosition *argp3 ;
76053   bool result;
76054
76055   arg1 = (Dali::Toolkit::TableView *)jarg1;
76056   argp2 = (Dali::Actor *)jarg2;
76057   if (!argp2) {
76058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76059     return 0;
76060   }
76061   arg2 = *argp2;
76062   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
76063   if (!argp3) {
76064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76065     return 0;
76066   }
76067   arg3 = *argp3;
76068   {
76069     try {
76070       result = (bool)(arg1)->AddChild(arg2,arg3);
76071     } catch (std::out_of_range& e) {
76072       {
76073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76074       };
76075     } catch (std::exception& e) {
76076       {
76077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76078       };
76079     } catch (...) {
76080       {
76081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76082       };
76083     }
76084   }
76085   jresult = result;
76086   return jresult;
76087 }
76088
76089
76090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
76091   void * jresult ;
76092   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76093   Dali::Toolkit::TableView::CellPosition arg2 ;
76094   Dali::Toolkit::TableView::CellPosition *argp2 ;
76095   Dali::Actor result;
76096
76097   arg1 = (Dali::Toolkit::TableView *)jarg1;
76098   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
76099   if (!argp2) {
76100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76101     return 0;
76102   }
76103   arg2 = *argp2;
76104   {
76105     try {
76106       result = (arg1)->GetChildAt(arg2);
76107     } catch (std::out_of_range& e) {
76108       {
76109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76110       };
76111     } catch (std::exception& e) {
76112       {
76113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76114       };
76115     } catch (...) {
76116       {
76117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76118       };
76119     }
76120   }
76121   jresult = new Dali::Actor((const Dali::Actor &)result);
76122   return jresult;
76123 }
76124
76125
76126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
76127   void * jresult ;
76128   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76129   Dali::Toolkit::TableView::CellPosition arg2 ;
76130   Dali::Toolkit::TableView::CellPosition *argp2 ;
76131   Dali::Actor result;
76132
76133   arg1 = (Dali::Toolkit::TableView *)jarg1;
76134   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
76135   if (!argp2) {
76136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76137     return 0;
76138   }
76139   arg2 = *argp2;
76140   {
76141     try {
76142       result = (arg1)->RemoveChildAt(arg2);
76143     } catch (std::out_of_range& e) {
76144       {
76145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76146       };
76147     } catch (std::exception& e) {
76148       {
76149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76150       };
76151     } catch (...) {
76152       {
76153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76154       };
76155     }
76156   }
76157   jresult = new Dali::Actor((const Dali::Actor &)result);
76158   return jresult;
76159 }
76160
76161
76162 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
76163   unsigned int jresult ;
76164   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76165   Dali::Actor arg2 ;
76166   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
76167   Dali::Actor *argp2 ;
76168   bool result;
76169
76170   arg1 = (Dali::Toolkit::TableView *)jarg1;
76171   argp2 = (Dali::Actor *)jarg2;
76172   if (!argp2) {
76173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76174     return 0;
76175   }
76176   arg2 = *argp2;
76177   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
76178   if (!arg3) {
76179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
76180     return 0;
76181   }
76182   {
76183     try {
76184       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
76185     } catch (std::out_of_range& e) {
76186       {
76187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76188       };
76189     } catch (std::exception& e) {
76190       {
76191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76192       };
76193     } catch (...) {
76194       {
76195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76196       };
76197     }
76198   }
76199   jresult = result;
76200   return jresult;
76201 }
76202
76203
76204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
76205   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76206   unsigned int arg2 ;
76207
76208   arg1 = (Dali::Toolkit::TableView *)jarg1;
76209   arg2 = (unsigned int)jarg2;
76210   {
76211     try {
76212       (arg1)->InsertRow(arg2);
76213     } catch (std::out_of_range& e) {
76214       {
76215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76216       };
76217     } catch (std::exception& e) {
76218       {
76219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76220       };
76221     } catch (...) {
76222       {
76223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76224       };
76225     }
76226   }
76227 }
76228
76229
76230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
76231   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76232   unsigned int arg2 ;
76233
76234   arg1 = (Dali::Toolkit::TableView *)jarg1;
76235   arg2 = (unsigned int)jarg2;
76236   {
76237     try {
76238       (arg1)->DeleteRow(arg2);
76239     } catch (std::out_of_range& e) {
76240       {
76241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76242       };
76243     } catch (std::exception& e) {
76244       {
76245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76246       };
76247     } catch (...) {
76248       {
76249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76250       };
76251     }
76252   }
76253 }
76254
76255
76256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
76257   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76258   unsigned int arg2 ;
76259   std::vector< Dali::Actor > *arg3 = 0 ;
76260
76261   arg1 = (Dali::Toolkit::TableView *)jarg1;
76262   arg2 = (unsigned int)jarg2;
76263   arg3 = (std::vector< Dali::Actor > *)jarg3;
76264   if (!arg3) {
76265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
76266     return ;
76267   }
76268   {
76269     try {
76270       (arg1)->DeleteRow(arg2,*arg3);
76271     } catch (std::out_of_range& e) {
76272       {
76273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76274       };
76275     } catch (std::exception& e) {
76276       {
76277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76278       };
76279     } catch (...) {
76280       {
76281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76282       };
76283     }
76284   }
76285 }
76286
76287
76288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
76289   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76290   unsigned int arg2 ;
76291
76292   arg1 = (Dali::Toolkit::TableView *)jarg1;
76293   arg2 = (unsigned int)jarg2;
76294   {
76295     try {
76296       (arg1)->InsertColumn(arg2);
76297     } catch (std::out_of_range& e) {
76298       {
76299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76300       };
76301     } catch (std::exception& e) {
76302       {
76303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76304       };
76305     } catch (...) {
76306       {
76307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76308       };
76309     }
76310   }
76311 }
76312
76313
76314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
76315   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76316   unsigned int arg2 ;
76317
76318   arg1 = (Dali::Toolkit::TableView *)jarg1;
76319   arg2 = (unsigned int)jarg2;
76320   {
76321     try {
76322       (arg1)->DeleteColumn(arg2);
76323     } catch (std::out_of_range& e) {
76324       {
76325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76326       };
76327     } catch (std::exception& e) {
76328       {
76329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76330       };
76331     } catch (...) {
76332       {
76333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76334       };
76335     }
76336   }
76337 }
76338
76339
76340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
76341   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76342   unsigned int arg2 ;
76343   std::vector< Dali::Actor > *arg3 = 0 ;
76344
76345   arg1 = (Dali::Toolkit::TableView *)jarg1;
76346   arg2 = (unsigned int)jarg2;
76347   arg3 = (std::vector< Dali::Actor > *)jarg3;
76348   if (!arg3) {
76349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
76350     return ;
76351   }
76352   {
76353     try {
76354       (arg1)->DeleteColumn(arg2,*arg3);
76355     } catch (std::out_of_range& e) {
76356       {
76357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76358       };
76359     } catch (std::exception& e) {
76360       {
76361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76362       };
76363     } catch (...) {
76364       {
76365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76366       };
76367     }
76368   }
76369 }
76370
76371
76372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
76373   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76374   unsigned int arg2 ;
76375   unsigned int arg3 ;
76376
76377   arg1 = (Dali::Toolkit::TableView *)jarg1;
76378   arg2 = (unsigned int)jarg2;
76379   arg3 = (unsigned int)jarg3;
76380   {
76381     try {
76382       (arg1)->Resize(arg2,arg3);
76383     } catch (std::out_of_range& e) {
76384       {
76385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76386       };
76387     } catch (std::exception& e) {
76388       {
76389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76390       };
76391     } catch (...) {
76392       {
76393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76394       };
76395     }
76396   }
76397 }
76398
76399
76400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
76401   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76402   unsigned int arg2 ;
76403   unsigned int arg3 ;
76404   std::vector< Dali::Actor > *arg4 = 0 ;
76405
76406   arg1 = (Dali::Toolkit::TableView *)jarg1;
76407   arg2 = (unsigned int)jarg2;
76408   arg3 = (unsigned int)jarg3;
76409   arg4 = (std::vector< Dali::Actor > *)jarg4;
76410   if (!arg4) {
76411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
76412     return ;
76413   }
76414   {
76415     try {
76416       (arg1)->Resize(arg2,arg3,*arg4);
76417     } catch (std::out_of_range& e) {
76418       {
76419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76420       };
76421     } catch (std::exception& e) {
76422       {
76423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76424       };
76425     } catch (...) {
76426       {
76427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76428       };
76429     }
76430   }
76431 }
76432
76433
76434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
76435   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76436   Dali::Size arg2 ;
76437   Dali::Size *argp2 ;
76438
76439   arg1 = (Dali::Toolkit::TableView *)jarg1;
76440   argp2 = (Dali::Size *)jarg2;
76441   if (!argp2) {
76442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
76443     return ;
76444   }
76445   arg2 = *argp2;
76446   {
76447     try {
76448       (arg1)->SetCellPadding(arg2);
76449     } catch (std::out_of_range& e) {
76450       {
76451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76452       };
76453     } catch (std::exception& e) {
76454       {
76455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76456       };
76457     } catch (...) {
76458       {
76459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76460       };
76461     }
76462   }
76463 }
76464
76465
76466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
76467   void * jresult ;
76468   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76469   Dali::Size result;
76470
76471   arg1 = (Dali::Toolkit::TableView *)jarg1;
76472   {
76473     try {
76474       result = (arg1)->GetCellPadding();
76475     } catch (std::out_of_range& e) {
76476       {
76477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76478       };
76479     } catch (std::exception& e) {
76480       {
76481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76482       };
76483     } catch (...) {
76484       {
76485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76486       };
76487     }
76488   }
76489   jresult = new Dali::Size((const Dali::Size &)result);
76490   return jresult;
76491 }
76492
76493
76494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
76495   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76496   unsigned int arg2 ;
76497
76498   arg1 = (Dali::Toolkit::TableView *)jarg1;
76499   arg2 = (unsigned int)jarg2;
76500   {
76501     try {
76502       (arg1)->SetFitHeight(arg2);
76503     } catch (std::out_of_range& e) {
76504       {
76505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76506       };
76507     } catch (std::exception& e) {
76508       {
76509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76510       };
76511     } catch (...) {
76512       {
76513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76514       };
76515     }
76516   }
76517 }
76518
76519
76520 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
76521   unsigned int jresult ;
76522   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76523   unsigned int arg2 ;
76524   bool result;
76525
76526   arg1 = (Dali::Toolkit::TableView *)jarg1;
76527   arg2 = (unsigned int)jarg2;
76528   {
76529     try {
76530       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
76531     } catch (std::out_of_range& e) {
76532       {
76533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76534       };
76535     } catch (std::exception& e) {
76536       {
76537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76538       };
76539     } catch (...) {
76540       {
76541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76542       };
76543     }
76544   }
76545   jresult = result;
76546   return jresult;
76547 }
76548
76549
76550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
76551   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76552   unsigned int arg2 ;
76553
76554   arg1 = (Dali::Toolkit::TableView *)jarg1;
76555   arg2 = (unsigned int)jarg2;
76556   {
76557     try {
76558       (arg1)->SetFitWidth(arg2);
76559     } catch (std::out_of_range& e) {
76560       {
76561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76562       };
76563     } catch (std::exception& e) {
76564       {
76565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76566       };
76567     } catch (...) {
76568       {
76569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76570       };
76571     }
76572   }
76573 }
76574
76575
76576 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
76577   unsigned int jresult ;
76578   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76579   unsigned int arg2 ;
76580   bool result;
76581
76582   arg1 = (Dali::Toolkit::TableView *)jarg1;
76583   arg2 = (unsigned int)jarg2;
76584   {
76585     try {
76586       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
76587     } catch (std::out_of_range& e) {
76588       {
76589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76590       };
76591     } catch (std::exception& e) {
76592       {
76593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76594       };
76595     } catch (...) {
76596       {
76597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76598       };
76599     }
76600   }
76601   jresult = result;
76602   return jresult;
76603 }
76604
76605
76606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
76607   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76608   unsigned int arg2 ;
76609   float arg3 ;
76610
76611   arg1 = (Dali::Toolkit::TableView *)jarg1;
76612   arg2 = (unsigned int)jarg2;
76613   arg3 = (float)jarg3;
76614   {
76615     try {
76616       (arg1)->SetFixedHeight(arg2,arg3);
76617     } catch (std::out_of_range& e) {
76618       {
76619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76620       };
76621     } catch (std::exception& e) {
76622       {
76623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76624       };
76625     } catch (...) {
76626       {
76627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76628       };
76629     }
76630   }
76631 }
76632
76633
76634 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
76635   float jresult ;
76636   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76637   unsigned int arg2 ;
76638   float result;
76639
76640   arg1 = (Dali::Toolkit::TableView *)jarg1;
76641   arg2 = (unsigned int)jarg2;
76642   {
76643     try {
76644       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
76645     } catch (std::out_of_range& e) {
76646       {
76647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76648       };
76649     } catch (std::exception& e) {
76650       {
76651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76652       };
76653     } catch (...) {
76654       {
76655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76656       };
76657     }
76658   }
76659   jresult = result;
76660   return jresult;
76661 }
76662
76663
76664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
76665   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76666   unsigned int arg2 ;
76667   float arg3 ;
76668
76669   arg1 = (Dali::Toolkit::TableView *)jarg1;
76670   arg2 = (unsigned int)jarg2;
76671   arg3 = (float)jarg3;
76672   {
76673     try {
76674       (arg1)->SetRelativeHeight(arg2,arg3);
76675     } catch (std::out_of_range& e) {
76676       {
76677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76678       };
76679     } catch (std::exception& e) {
76680       {
76681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76682       };
76683     } catch (...) {
76684       {
76685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76686       };
76687     }
76688   }
76689 }
76690
76691
76692 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
76693   float jresult ;
76694   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76695   unsigned int arg2 ;
76696   float result;
76697
76698   arg1 = (Dali::Toolkit::TableView *)jarg1;
76699   arg2 = (unsigned int)jarg2;
76700   {
76701     try {
76702       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
76703     } catch (std::out_of_range& e) {
76704       {
76705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76706       };
76707     } catch (std::exception& e) {
76708       {
76709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76710       };
76711     } catch (...) {
76712       {
76713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76714       };
76715     }
76716   }
76717   jresult = result;
76718   return jresult;
76719 }
76720
76721
76722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
76723   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76724   unsigned int arg2 ;
76725   float arg3 ;
76726
76727   arg1 = (Dali::Toolkit::TableView *)jarg1;
76728   arg2 = (unsigned int)jarg2;
76729   arg3 = (float)jarg3;
76730   {
76731     try {
76732       (arg1)->SetFixedWidth(arg2,arg3);
76733     } catch (std::out_of_range& e) {
76734       {
76735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76736       };
76737     } catch (std::exception& e) {
76738       {
76739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76740       };
76741     } catch (...) {
76742       {
76743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76744       };
76745     }
76746   }
76747 }
76748
76749
76750 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
76751   float jresult ;
76752   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76753   unsigned int arg2 ;
76754   float result;
76755
76756   arg1 = (Dali::Toolkit::TableView *)jarg1;
76757   arg2 = (unsigned int)jarg2;
76758   {
76759     try {
76760       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
76761     } catch (std::out_of_range& e) {
76762       {
76763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76764       };
76765     } catch (std::exception& e) {
76766       {
76767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76768       };
76769     } catch (...) {
76770       {
76771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76772       };
76773     }
76774   }
76775   jresult = result;
76776   return jresult;
76777 }
76778
76779
76780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
76781   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76782   unsigned int arg2 ;
76783   float arg3 ;
76784
76785   arg1 = (Dali::Toolkit::TableView *)jarg1;
76786   arg2 = (unsigned int)jarg2;
76787   arg3 = (float)jarg3;
76788   {
76789     try {
76790       (arg1)->SetRelativeWidth(arg2,arg3);
76791     } catch (std::out_of_range& e) {
76792       {
76793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76794       };
76795     } catch (std::exception& e) {
76796       {
76797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76798       };
76799     } catch (...) {
76800       {
76801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76802       };
76803     }
76804   }
76805 }
76806
76807
76808 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
76809   float jresult ;
76810   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76811   unsigned int arg2 ;
76812   float result;
76813
76814   arg1 = (Dali::Toolkit::TableView *)jarg1;
76815   arg2 = (unsigned int)jarg2;
76816   {
76817     try {
76818       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
76819     } catch (std::out_of_range& e) {
76820       {
76821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76822       };
76823     } catch (std::exception& e) {
76824       {
76825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76826       };
76827     } catch (...) {
76828       {
76829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76830       };
76831     }
76832   }
76833   jresult = result;
76834   return jresult;
76835 }
76836
76837
76838 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
76839   unsigned int jresult ;
76840   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76841   unsigned int result;
76842
76843   arg1 = (Dali::Toolkit::TableView *)jarg1;
76844   {
76845     try {
76846       result = (unsigned int)(arg1)->GetRows();
76847     } catch (std::out_of_range& e) {
76848       {
76849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76850       };
76851     } catch (std::exception& e) {
76852       {
76853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76854       };
76855     } catch (...) {
76856       {
76857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76858       };
76859     }
76860   }
76861   jresult = result;
76862   return jresult;
76863 }
76864
76865
76866 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
76867   unsigned int jresult ;
76868   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76869   unsigned int result;
76870
76871   arg1 = (Dali::Toolkit::TableView *)jarg1;
76872   {
76873     try {
76874       result = (unsigned int)(arg1)->GetColumns();
76875     } catch (std::out_of_range& e) {
76876       {
76877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76878       };
76879     } catch (std::exception& e) {
76880       {
76881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76882       };
76883     } catch (...) {
76884       {
76885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76886       };
76887     }
76888   }
76889   jresult = result;
76890   return jresult;
76891 }
76892
76893
76894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
76895   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76896   Dali::Toolkit::TableView::CellPosition arg2 ;
76897   Dali::HorizontalAlignment::Type arg3 ;
76898   Dali::VerticalAlignment::Type arg4 ;
76899   Dali::Toolkit::TableView::CellPosition *argp2 ;
76900
76901   arg1 = (Dali::Toolkit::TableView *)jarg1;
76902   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
76903   if (!argp2) {
76904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76905     return ;
76906   }
76907   arg2 = *argp2;
76908   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
76909   arg4 = (Dali::VerticalAlignment::Type)jarg4;
76910   {
76911     try {
76912       (arg1)->SetCellAlignment(arg2,arg3,arg4);
76913     } catch (std::out_of_range& e) {
76914       {
76915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76916       };
76917     } catch (std::exception& e) {
76918       {
76919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76920       };
76921     } catch (...) {
76922       {
76923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76924       };
76925     }
76926   }
76927 }
76928
76929
76930 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
76931   unsigned int jresult ;
76932   unsigned int result;
76933
76934   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
76935   jresult = result;
76936   return jresult;
76937 }
76938
76939
76940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_RENDERING_BACKEND_get() {
76941   int jresult ;
76942   int result;
76943
76944   result = (int)Dali::Toolkit::TextEditor::Property::RENDERING_BACKEND;
76945   jresult = (int)result;
76946   return jresult;
76947 }
76948
76949
76950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_get() {
76951   int jresult ;
76952   int result;
76953
76954   result = (int)Dali::Toolkit::TextEditor::Property::TEXT;
76955   jresult = (int)result;
76956   return jresult;
76957 }
76958
76959
76960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_COLOR_get() {
76961   int jresult ;
76962   int result;
76963
76964   result = (int)Dali::Toolkit::TextEditor::Property::TEXT_COLOR;
76965   jresult = (int)result;
76966   return jresult;
76967 }
76968
76969
76970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_FAMILY_get() {
76971   int jresult ;
76972   int result;
76973
76974   result = (int)Dali::Toolkit::TextEditor::Property::FONT_FAMILY;
76975   jresult = (int)result;
76976   return jresult;
76977 }
76978
76979
76980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_STYLE_get() {
76981   int jresult ;
76982   int result;
76983
76984   result = (int)Dali::Toolkit::TextEditor::Property::FONT_STYLE;
76985   jresult = (int)result;
76986   return jresult;
76987 }
76988
76989
76990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_POINT_SIZE_get() {
76991   int jresult ;
76992   int result;
76993
76994   result = (int)Dali::Toolkit::TextEditor::Property::POINT_SIZE;
76995   jresult = (int)result;
76996   return jresult;
76997 }
76998
76999
77000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_HORIZONTAL_ALIGNMENT_get() {
77001   int jresult ;
77002   int result;
77003
77004   result = (int)Dali::Toolkit::TextEditor::Property::HORIZONTAL_ALIGNMENT;
77005   jresult = (int)result;
77006   return jresult;
77007 }
77008
77009
77010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_THRESHOLD_get() {
77011   int jresult ;
77012   int result;
77013
77014   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_THRESHOLD;
77015   jresult = (int)result;
77016   return jresult;
77017 }
77018
77019
77020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_SPEED_get() {
77021   int jresult ;
77022   int result;
77023
77024   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_SPEED;
77025   jresult = (int)result;
77026   return jresult;
77027 }
77028
77029
77030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_PRIMARY_CURSOR_COLOR_get() {
77031   int jresult ;
77032   int result;
77033
77034   result = (int)Dali::Toolkit::TextEditor::Property::PRIMARY_CURSOR_COLOR;
77035   jresult = (int)result;
77036   return jresult;
77037 }
77038
77039
77040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SECONDARY_CURSOR_COLOR_get() {
77041   int jresult ;
77042   int result;
77043
77044   result = (int)Dali::Toolkit::TextEditor::Property::SECONDARY_CURSOR_COLOR;
77045   jresult = (int)result;
77046   return jresult;
77047 }
77048
77049
77050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_CURSOR_BLINK_get() {
77051   int jresult ;
77052   int result;
77053
77054   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_CURSOR_BLINK;
77055   jresult = (int)result;
77056   return jresult;
77057 }
77058
77059
77060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_INTERVAL_get() {
77061   int jresult ;
77062   int result;
77063
77064   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_INTERVAL;
77065   jresult = (int)result;
77066   return jresult;
77067 }
77068
77069
77070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_DURATION_get() {
77071   int jresult ;
77072   int result;
77073
77074   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_DURATION;
77075   jresult = (int)result;
77076   return jresult;
77077 }
77078
77079
77080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_WIDTH_get() {
77081   int jresult ;
77082   int result;
77083
77084   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_WIDTH;
77085   jresult = (int)result;
77086   return jresult;
77087 }
77088
77089
77090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_IMAGE_get() {
77091   int jresult ;
77092   int result;
77093
77094   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_IMAGE;
77095   jresult = (int)result;
77096   return jresult;
77097 }
77098
77099
77100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
77101   int jresult ;
77102   int result;
77103
77104   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_PRESSED_IMAGE;
77105   jresult = (int)result;
77106   return jresult;
77107 }
77108
77109
77110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
77111   int jresult ;
77112   int result;
77113
77114   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_LEFT;
77115   jresult = (int)result;
77116   return jresult;
77117 }
77118
77119
77120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
77121   int jresult ;
77122   int result;
77123
77124   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_RIGHT;
77125   jresult = (int)result;
77126   return jresult;
77127 }
77128
77129
77130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
77131   int jresult ;
77132   int result;
77133
77134   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
77135   jresult = (int)result;
77136   return jresult;
77137 }
77138
77139
77140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
77141   int jresult ;
77142   int result;
77143
77144   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
77145   jresult = (int)result;
77146   return jresult;
77147 }
77148
77149
77150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
77151   int jresult ;
77152   int result;
77153
77154   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
77155   jresult = (int)result;
77156   return jresult;
77157 }
77158
77159
77160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
77161   int jresult ;
77162   int result;
77163
77164   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
77165   jresult = (int)result;
77166   return jresult;
77167 }
77168
77169
77170 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HIGHLIGHT_COLOR_get() {
77171   int jresult ;
77172   int result;
77173
77174   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HIGHLIGHT_COLOR;
77175   jresult = (int)result;
77176   return jresult;
77177 }
77178
77179
77180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_DECORATION_BOUNDING_BOX_get() {
77181   int jresult ;
77182   int result;
77183
77184   result = (int)Dali::Toolkit::TextEditor::Property::DECORATION_BOUNDING_BOX;
77185   jresult = (int)result;
77186   return jresult;
77187 }
77188
77189
77190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_MARKUP_get() {
77191   int jresult ;
77192   int result;
77193
77194   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_MARKUP;
77195   jresult = (int)result;
77196   return jresult;
77197 }
77198
77199
77200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_COLOR_get() {
77201   int jresult ;
77202   int result;
77203
77204   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_COLOR;
77205   jresult = (int)result;
77206   return jresult;
77207 }
77208
77209
77210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_FAMILY_get() {
77211   int jresult ;
77212   int result;
77213
77214   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_FAMILY;
77215   jresult = (int)result;
77216   return jresult;
77217 }
77218
77219
77220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_STYLE_get() {
77221   int jresult ;
77222   int result;
77223
77224   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_STYLE;
77225   jresult = (int)result;
77226   return jresult;
77227 }
77228
77229
77230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_POINT_SIZE_get() {
77231   int jresult ;
77232   int result;
77233
77234   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_POINT_SIZE;
77235   jresult = (int)result;
77236   return jresult;
77237 }
77238
77239
77240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_LINE_SPACING_get() {
77241   int jresult ;
77242   int result;
77243
77244   result = (int)Dali::Toolkit::TextEditor::Property::LINE_SPACING;
77245   jresult = (int)result;
77246   return jresult;
77247 }
77248
77249
77250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_LINE_SPACING_get() {
77251   int jresult ;
77252   int result;
77253
77254   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_LINE_SPACING;
77255   jresult = (int)result;
77256   return jresult;
77257 }
77258
77259
77260 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_UNDERLINE_get() {
77261   int jresult ;
77262   int result;
77263
77264   result = (int)Dali::Toolkit::TextEditor::Property::UNDERLINE;
77265   jresult = (int)result;
77266   return jresult;
77267 }
77268
77269
77270 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_UNDERLINE_get() {
77271   int jresult ;
77272   int result;
77273
77274   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_UNDERLINE;
77275   jresult = (int)result;
77276   return jresult;
77277 }
77278
77279
77280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SHADOW_get() {
77281   int jresult ;
77282   int result;
77283
77284   result = (int)Dali::Toolkit::TextEditor::Property::SHADOW;
77285   jresult = (int)result;
77286   return jresult;
77287 }
77288
77289
77290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_SHADOW_get() {
77291   int jresult ;
77292   int result;
77293
77294   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_SHADOW;
77295   jresult = (int)result;
77296   return jresult;
77297 }
77298
77299
77300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_EMBOSS_get() {
77301   int jresult ;
77302   int result;
77303
77304   result = (int)Dali::Toolkit::TextEditor::Property::EMBOSS;
77305   jresult = (int)result;
77306   return jresult;
77307 }
77308
77309
77310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_EMBOSS_get() {
77311   int jresult ;
77312   int result;
77313
77314   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_EMBOSS;
77315   jresult = (int)result;
77316   return jresult;
77317 }
77318
77319
77320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_OUTLINE_get() {
77321   int jresult ;
77322   int result;
77323
77324   result = (int)Dali::Toolkit::TextEditor::Property::OUTLINE;
77325   jresult = (int)result;
77326   return jresult;
77327 }
77328
77329
77330 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_OUTLINE_get() {
77331   int jresult ;
77332   int result;
77333
77334   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_OUTLINE;
77335   jresult = (int)result;
77336   return jresult;
77337 }
77338
77339
77340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_Property() {
77341   void * jresult ;
77342   Dali::Toolkit::TextEditor::Property *result = 0 ;
77343
77344   {
77345     try {
77346       result = (Dali::Toolkit::TextEditor::Property *)new Dali::Toolkit::TextEditor::Property();
77347     } catch (std::out_of_range& e) {
77348       {
77349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77350       };
77351     } catch (std::exception& e) {
77352       {
77353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77354       };
77355     } catch (...) {
77356       {
77357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77358       };
77359     }
77360   }
77361   jresult = (void *)result;
77362   return jresult;
77363 }
77364
77365
77366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_Property(void * jarg1) {
77367   Dali::Toolkit::TextEditor::Property *arg1 = (Dali::Toolkit::TextEditor::Property *) 0 ;
77368
77369   arg1 = (Dali::Toolkit::TextEditor::Property *)jarg1;
77370   {
77371     try {
77372       delete arg1;
77373     } catch (std::out_of_range& e) {
77374       {
77375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77376       };
77377     } catch (std::exception& e) {
77378       {
77379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77380       };
77381     } catch (...) {
77382       {
77383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77384       };
77385     }
77386   }
77387 }
77388
77389
77390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_InputStyle() {
77391   void * jresult ;
77392   Dali::Toolkit::TextEditor::InputStyle *result = 0 ;
77393
77394   {
77395     try {
77396       result = (Dali::Toolkit::TextEditor::InputStyle *)new Dali::Toolkit::TextEditor::InputStyle();
77397     } catch (std::out_of_range& e) {
77398       {
77399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77400       };
77401     } catch (std::exception& e) {
77402       {
77403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77404       };
77405     } catch (...) {
77406       {
77407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77408       };
77409     }
77410   }
77411   jresult = (void *)result;
77412   return jresult;
77413 }
77414
77415
77416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_InputStyle(void * jarg1) {
77417   Dali::Toolkit::TextEditor::InputStyle *arg1 = (Dali::Toolkit::TextEditor::InputStyle *) 0 ;
77418
77419   arg1 = (Dali::Toolkit::TextEditor::InputStyle *)jarg1;
77420   {
77421     try {
77422       delete arg1;
77423     } catch (std::out_of_range& e) {
77424       {
77425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77426       };
77427     } catch (std::exception& e) {
77428       {
77429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77430       };
77431     } catch (...) {
77432       {
77433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77434       };
77435     }
77436   }
77437 }
77438
77439
77440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_New() {
77441   void * jresult ;
77442   Dali::Toolkit::TextEditor result;
77443
77444   {
77445     try {
77446       result = Dali::Toolkit::TextEditor::New();
77447     } catch (std::out_of_range& e) {
77448       {
77449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77450       };
77451     } catch (std::exception& e) {
77452       {
77453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77454       };
77455     } catch (...) {
77456       {
77457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77458       };
77459     }
77460   }
77461   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
77462   return jresult;
77463 }
77464
77465
77466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_0() {
77467   void * jresult ;
77468   Dali::Toolkit::TextEditor *result = 0 ;
77469
77470   {
77471     try {
77472       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor();
77473     } catch (std::out_of_range& e) {
77474       {
77475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77476       };
77477     } catch (std::exception& e) {
77478       {
77479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77480       };
77481     } catch (...) {
77482       {
77483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77484       };
77485     }
77486   }
77487   jresult = (void *)result;
77488   return jresult;
77489 }
77490
77491
77492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_1(void * jarg1) {
77493   void * jresult ;
77494   Dali::Toolkit::TextEditor *arg1 = 0 ;
77495   Dali::Toolkit::TextEditor *result = 0 ;
77496
77497   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77498   if (!arg1) {
77499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
77500     return 0;
77501   }
77502   {
77503     try {
77504       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor((Dali::Toolkit::TextEditor const &)*arg1);
77505     } catch (std::out_of_range& e) {
77506       {
77507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77508       };
77509     } catch (std::exception& e) {
77510       {
77511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77512       };
77513     } catch (...) {
77514       {
77515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77516       };
77517     }
77518   }
77519   jresult = (void *)result;
77520   return jresult;
77521 }
77522
77523
77524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_Assign(void * jarg1, void * jarg2) {
77525   void * jresult ;
77526   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
77527   Dali::Toolkit::TextEditor *arg2 = 0 ;
77528   Dali::Toolkit::TextEditor *result = 0 ;
77529
77530   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77531   arg2 = (Dali::Toolkit::TextEditor *)jarg2;
77532   if (!arg2) {
77533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
77534     return 0;
77535   }
77536   {
77537     try {
77538       result = (Dali::Toolkit::TextEditor *) &(arg1)->operator =((Dali::Toolkit::TextEditor const &)*arg2);
77539     } catch (std::out_of_range& e) {
77540       {
77541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77542       };
77543     } catch (std::exception& e) {
77544       {
77545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77546       };
77547     } catch (...) {
77548       {
77549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77550       };
77551     }
77552   }
77553   jresult = (void *)result;
77554   return jresult;
77555 }
77556
77557
77558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor(void * jarg1) {
77559   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
77560
77561   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77562   {
77563     try {
77564       delete arg1;
77565     } catch (std::out_of_range& e) {
77566       {
77567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77568       };
77569     } catch (std::exception& e) {
77570       {
77571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77572       };
77573     } catch (...) {
77574       {
77575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77576       };
77577     }
77578   }
77579 }
77580
77581
77582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_DownCast(void * jarg1) {
77583   void * jresult ;
77584   Dali::BaseHandle arg1 ;
77585   Dali::BaseHandle *argp1 ;
77586   Dali::Toolkit::TextEditor result;
77587
77588   argp1 = (Dali::BaseHandle *)jarg1;
77589   if (!argp1) {
77590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77591     return 0;
77592   }
77593   arg1 = *argp1;
77594   {
77595     try {
77596       result = Dali::Toolkit::TextEditor::DownCast(arg1);
77597     } catch (std::out_of_range& e) {
77598       {
77599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77600       };
77601     } catch (std::exception& e) {
77602       {
77603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77604       };
77605     } catch (...) {
77606       {
77607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77608       };
77609     }
77610   }
77611   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
77612   return jresult;
77613 }
77614
77615
77616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_TextChangedSignal(void * jarg1) {
77617   void * jresult ;
77618   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
77619   Dali::Toolkit::TextEditor::TextChangedSignalType *result = 0 ;
77620
77621   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77622   {
77623     try {
77624       result = (Dali::Toolkit::TextEditor::TextChangedSignalType *) &(arg1)->TextChangedSignal();
77625     } catch (std::out_of_range& e) {
77626       {
77627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77628       };
77629     } catch (std::exception& e) {
77630       {
77631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77632       };
77633     } catch (...) {
77634       {
77635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77636       };
77637     }
77638   }
77639   jresult = (void *)result;
77640   return jresult;
77641 }
77642
77643
77644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_InputStyleChangedSignal(void * jarg1) {
77645   void * jresult ;
77646   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
77647   Dali::Toolkit::TextEditor::InputStyleChangedSignalType *result = 0 ;
77648
77649   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77650   {
77651     try {
77652       result = (Dali::Toolkit::TextEditor::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
77653     } catch (std::out_of_range& e) {
77654       {
77655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77656       };
77657     } catch (std::exception& e) {
77658       {
77659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77660       };
77661     } catch (...) {
77662       {
77663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77664       };
77665     }
77666   }
77667   jresult = (void *)result;
77668   return jresult;
77669 }
77670
77671
77672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_RENDERING_BACKEND_get() {
77673   int jresult ;
77674   int result;
77675
77676   result = (int)Dali::Toolkit::TextField::Property::RENDERING_BACKEND;
77677   jresult = (int)result;
77678   return jresult;
77679 }
77680
77681
77682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_get() {
77683   int jresult ;
77684   int result;
77685
77686   result = (int)Dali::Toolkit::TextField::Property::TEXT;
77687   jresult = (int)result;
77688   return jresult;
77689 }
77690
77691
77692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_get() {
77693   int jresult ;
77694   int result;
77695
77696   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT;
77697   jresult = (int)result;
77698   return jresult;
77699 }
77700
77701
77702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_FOCUSED_get() {
77703   int jresult ;
77704   int result;
77705
77706   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_FOCUSED;
77707   jresult = (int)result;
77708   return jresult;
77709 }
77710
77711
77712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_FAMILY_get() {
77713   int jresult ;
77714   int result;
77715
77716   result = (int)Dali::Toolkit::TextField::Property::FONT_FAMILY;
77717   jresult = (int)result;
77718   return jresult;
77719 }
77720
77721
77722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_STYLE_get() {
77723   int jresult ;
77724   int result;
77725
77726   result = (int)Dali::Toolkit::TextField::Property::FONT_STYLE;
77727   jresult = (int)result;
77728   return jresult;
77729 }
77730
77731
77732 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_POINT_SIZE_get() {
77733   int jresult ;
77734   int result;
77735
77736   result = (int)Dali::Toolkit::TextField::Property::POINT_SIZE;
77737   jresult = (int)result;
77738   return jresult;
77739 }
77740
77741
77742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_MAX_LENGTH_get() {
77743   int jresult ;
77744   int result;
77745
77746   result = (int)Dali::Toolkit::TextField::Property::MAX_LENGTH;
77747   jresult = (int)result;
77748   return jresult;
77749 }
77750
77751
77752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EXCEED_POLICY_get() {
77753   int jresult ;
77754   int result;
77755
77756   result = (int)Dali::Toolkit::TextField::Property::EXCEED_POLICY;
77757   jresult = (int)result;
77758   return jresult;
77759 }
77760
77761
77762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_HORIZONTAL_ALIGNMENT_get() {
77763   int jresult ;
77764   int result;
77765
77766   result = (int)Dali::Toolkit::TextField::Property::HORIZONTAL_ALIGNMENT;
77767   jresult = (int)result;
77768   return jresult;
77769 }
77770
77771
77772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_VERTICAL_ALIGNMENT_get() {
77773   int jresult ;
77774   int result;
77775
77776   result = (int)Dali::Toolkit::TextField::Property::VERTICAL_ALIGNMENT;
77777   jresult = (int)result;
77778   return jresult;
77779 }
77780
77781
77782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_COLOR_get() {
77783   int jresult ;
77784   int result;
77785
77786   result = (int)Dali::Toolkit::TextField::Property::TEXT_COLOR;
77787   jresult = (int)result;
77788   return jresult;
77789 }
77790
77791
77792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_COLOR_get() {
77793   int jresult ;
77794   int result;
77795
77796   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_COLOR;
77797   jresult = (int)result;
77798   return jresult;
77799 }
77800
77801
77802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_OFFSET_get() {
77803   int jresult ;
77804   int result;
77805
77806   result = (int)Dali::Toolkit::TextField::Property::SHADOW_OFFSET;
77807   jresult = (int)result;
77808   return jresult;
77809 }
77810
77811
77812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_COLOR_get() {
77813   int jresult ;
77814   int result;
77815
77816   result = (int)Dali::Toolkit::TextField::Property::SHADOW_COLOR;
77817   jresult = (int)result;
77818   return jresult;
77819 }
77820
77821
77822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PRIMARY_CURSOR_COLOR_get() {
77823   int jresult ;
77824   int result;
77825
77826   result = (int)Dali::Toolkit::TextField::Property::PRIMARY_CURSOR_COLOR;
77827   jresult = (int)result;
77828   return jresult;
77829 }
77830
77831
77832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SECONDARY_CURSOR_COLOR_get() {
77833   int jresult ;
77834   int result;
77835
77836   result = (int)Dali::Toolkit::TextField::Property::SECONDARY_CURSOR_COLOR;
77837   jresult = (int)result;
77838   return jresult;
77839 }
77840
77841
77842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_CURSOR_BLINK_get() {
77843   int jresult ;
77844   int result;
77845
77846   result = (int)Dali::Toolkit::TextField::Property::ENABLE_CURSOR_BLINK;
77847   jresult = (int)result;
77848   return jresult;
77849 }
77850
77851
77852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_INTERVAL_get() {
77853   int jresult ;
77854   int result;
77855
77856   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_INTERVAL;
77857   jresult = (int)result;
77858   return jresult;
77859 }
77860
77861
77862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_DURATION_get() {
77863   int jresult ;
77864   int result;
77865
77866   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_DURATION;
77867   jresult = (int)result;
77868   return jresult;
77869 }
77870
77871
77872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_WIDTH_get() {
77873   int jresult ;
77874   int result;
77875
77876   result = (int)Dali::Toolkit::TextField::Property::CURSOR_WIDTH;
77877   jresult = (int)result;
77878   return jresult;
77879 }
77880
77881
77882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_IMAGE_get() {
77883   int jresult ;
77884   int result;
77885
77886   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_IMAGE;
77887   jresult = (int)result;
77888   return jresult;
77889 }
77890
77891
77892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
77893   int jresult ;
77894   int result;
77895
77896   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_PRESSED_IMAGE;
77897   jresult = (int)result;
77898   return jresult;
77899 }
77900
77901
77902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_THRESHOLD_get() {
77903   int jresult ;
77904   int result;
77905
77906   result = (int)Dali::Toolkit::TextField::Property::SCROLL_THRESHOLD;
77907   jresult = (int)result;
77908   return jresult;
77909 }
77910
77911
77912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_SPEED_get() {
77913   int jresult ;
77914   int result;
77915
77916   result = (int)Dali::Toolkit::TextField::Property::SCROLL_SPEED;
77917   jresult = (int)result;
77918   return jresult;
77919 }
77920
77921
77922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
77923   int jresult ;
77924   int result;
77925
77926   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_LEFT;
77927   jresult = (int)result;
77928   return jresult;
77929 }
77930
77931
77932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
77933   int jresult ;
77934   int result;
77935
77936   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_RIGHT;
77937   jresult = (int)result;
77938   return jresult;
77939 }
77940
77941
77942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
77943   int jresult ;
77944   int result;
77945
77946   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
77947   jresult = (int)result;
77948   return jresult;
77949 }
77950
77951
77952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
77953   int jresult ;
77954   int result;
77955
77956   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
77957   jresult = (int)result;
77958   return jresult;
77959 }
77960
77961
77962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
77963   int jresult ;
77964   int result;
77965
77966   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
77967   jresult = (int)result;
77968   return jresult;
77969 }
77970
77971
77972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
77973   int jresult ;
77974   int result;
77975
77976   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
77977   jresult = (int)result;
77978   return jresult;
77979 }
77980
77981
77982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HIGHLIGHT_COLOR_get() {
77983   int jresult ;
77984   int result;
77985
77986   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HIGHLIGHT_COLOR;
77987   jresult = (int)result;
77988   return jresult;
77989 }
77990
77991
77992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_DECORATION_BOUNDING_BOX_get() {
77993   int jresult ;
77994   int result;
77995
77996   result = (int)Dali::Toolkit::TextField::Property::DECORATION_BOUNDING_BOX;
77997   jresult = (int)result;
77998   return jresult;
77999 }
78000
78001
78002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_METHOD_SETTINGS_get() {
78003   int jresult ;
78004   int result;
78005
78006   result = (int)Dali::Toolkit::TextField::Property::INPUT_METHOD_SETTINGS;
78007   jresult = (int)result;
78008   return jresult;
78009 }
78010
78011
78012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_COLOR_get() {
78013   int jresult ;
78014   int result;
78015
78016   result = (int)Dali::Toolkit::TextField::Property::INPUT_COLOR;
78017   jresult = (int)result;
78018   return jresult;
78019 }
78020
78021
78022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_MARKUP_get() {
78023   int jresult ;
78024   int result;
78025
78026   result = (int)Dali::Toolkit::TextField::Property::ENABLE_MARKUP;
78027   jresult = (int)result;
78028   return jresult;
78029 }
78030
78031
78032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_FAMILY_get() {
78033   int jresult ;
78034   int result;
78035
78036   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_FAMILY;
78037   jresult = (int)result;
78038   return jresult;
78039 }
78040
78041
78042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_STYLE_get() {
78043   int jresult ;
78044   int result;
78045
78046   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_STYLE;
78047   jresult = (int)result;
78048   return jresult;
78049 }
78050
78051
78052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_POINT_SIZE_get() {
78053   int jresult ;
78054   int result;
78055
78056   result = (int)Dali::Toolkit::TextField::Property::INPUT_POINT_SIZE;
78057   jresult = (int)result;
78058   return jresult;
78059 }
78060
78061
78062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_UNDERLINE_get() {
78063   int jresult ;
78064   int result;
78065
78066   result = (int)Dali::Toolkit::TextField::Property::UNDERLINE;
78067   jresult = (int)result;
78068   return jresult;
78069 }
78070
78071
78072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_UNDERLINE_get() {
78073   int jresult ;
78074   int result;
78075
78076   result = (int)Dali::Toolkit::TextField::Property::INPUT_UNDERLINE;
78077   jresult = (int)result;
78078   return jresult;
78079 }
78080
78081
78082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_get() {
78083   int jresult ;
78084   int result;
78085
78086   result = (int)Dali::Toolkit::TextField::Property::SHADOW;
78087   jresult = (int)result;
78088   return jresult;
78089 }
78090
78091
78092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_SHADOW_get() {
78093   int jresult ;
78094   int result;
78095
78096   result = (int)Dali::Toolkit::TextField::Property::INPUT_SHADOW;
78097   jresult = (int)result;
78098   return jresult;
78099 }
78100
78101
78102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EMBOSS_get() {
78103   int jresult ;
78104   int result;
78105
78106   result = (int)Dali::Toolkit::TextField::Property::EMBOSS;
78107   jresult = (int)result;
78108   return jresult;
78109 }
78110
78111
78112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_EMBOSS_get() {
78113   int jresult ;
78114   int result;
78115
78116   result = (int)Dali::Toolkit::TextField::Property::INPUT_EMBOSS;
78117   jresult = (int)result;
78118   return jresult;
78119 }
78120
78121
78122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_OUTLINE_get() {
78123   int jresult ;
78124   int result;
78125
78126   result = (int)Dali::Toolkit::TextField::Property::OUTLINE;
78127   jresult = (int)result;
78128   return jresult;
78129 }
78130
78131
78132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_OUTLINE_get() {
78133   int jresult ;
78134   int result;
78135
78136   result = (int)Dali::Toolkit::TextField::Property::INPUT_OUTLINE;
78137   jresult = (int)result;
78138   return jresult;
78139 }
78140
78141
78142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_Property() {
78143   void * jresult ;
78144   Dali::Toolkit::TextField::Property *result = 0 ;
78145
78146   {
78147     try {
78148       result = (Dali::Toolkit::TextField::Property *)new Dali::Toolkit::TextField::Property();
78149     } catch (std::out_of_range& e) {
78150       {
78151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78152       };
78153     } catch (std::exception& e) {
78154       {
78155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78156       };
78157     } catch (...) {
78158       {
78159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78160       };
78161     }
78162   }
78163   jresult = (void *)result;
78164   return jresult;
78165 }
78166
78167
78168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_Property(void * jarg1) {
78169   Dali::Toolkit::TextField::Property *arg1 = (Dali::Toolkit::TextField::Property *) 0 ;
78170
78171   arg1 = (Dali::Toolkit::TextField::Property *)jarg1;
78172   {
78173     try {
78174       delete arg1;
78175     } catch (std::out_of_range& e) {
78176       {
78177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78178       };
78179     } catch (std::exception& e) {
78180       {
78181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78182       };
78183     } catch (...) {
78184       {
78185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78186       };
78187     }
78188   }
78189 }
78190
78191
78192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_InputStyle() {
78193   void * jresult ;
78194   Dali::Toolkit::TextField::InputStyle *result = 0 ;
78195
78196   {
78197     try {
78198       result = (Dali::Toolkit::TextField::InputStyle *)new Dali::Toolkit::TextField::InputStyle();
78199     } catch (std::out_of_range& e) {
78200       {
78201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78202       };
78203     } catch (std::exception& e) {
78204       {
78205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78206       };
78207     } catch (...) {
78208       {
78209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78210       };
78211     }
78212   }
78213   jresult = (void *)result;
78214   return jresult;
78215 }
78216
78217
78218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_InputStyle(void * jarg1) {
78219   Dali::Toolkit::TextField::InputStyle *arg1 = (Dali::Toolkit::TextField::InputStyle *) 0 ;
78220
78221   arg1 = (Dali::Toolkit::TextField::InputStyle *)jarg1;
78222   {
78223     try {
78224       delete arg1;
78225     } catch (std::out_of_range& e) {
78226       {
78227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78228       };
78229     } catch (std::exception& e) {
78230       {
78231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78232       };
78233     } catch (...) {
78234       {
78235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78236       };
78237     }
78238   }
78239 }
78240
78241
78242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_New() {
78243   void * jresult ;
78244   Dali::Toolkit::TextField result;
78245
78246   {
78247     try {
78248       result = Dali::Toolkit::TextField::New();
78249     } catch (std::out_of_range& e) {
78250       {
78251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78252       };
78253     } catch (std::exception& e) {
78254       {
78255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78256       };
78257     } catch (...) {
78258       {
78259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78260       };
78261     }
78262   }
78263   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
78264   return jresult;
78265 }
78266
78267
78268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_0() {
78269   void * jresult ;
78270   Dali::Toolkit::TextField *result = 0 ;
78271
78272   {
78273     try {
78274       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField();
78275     } catch (std::out_of_range& e) {
78276       {
78277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78278       };
78279     } catch (std::exception& e) {
78280       {
78281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78282       };
78283     } catch (...) {
78284       {
78285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78286       };
78287     }
78288   }
78289   jresult = (void *)result;
78290   return jresult;
78291 }
78292
78293
78294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_1(void * jarg1) {
78295   void * jresult ;
78296   Dali::Toolkit::TextField *arg1 = 0 ;
78297   Dali::Toolkit::TextField *result = 0 ;
78298
78299   arg1 = (Dali::Toolkit::TextField *)jarg1;
78300   if (!arg1) {
78301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
78302     return 0;
78303   }
78304   {
78305     try {
78306       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField((Dali::Toolkit::TextField const &)*arg1);
78307     } catch (std::out_of_range& e) {
78308       {
78309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78310       };
78311     } catch (std::exception& e) {
78312       {
78313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78314       };
78315     } catch (...) {
78316       {
78317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78318       };
78319     }
78320   }
78321   jresult = (void *)result;
78322   return jresult;
78323 }
78324
78325
78326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_Assign(void * jarg1, void * jarg2) {
78327   void * jresult ;
78328   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78329   Dali::Toolkit::TextField *arg2 = 0 ;
78330   Dali::Toolkit::TextField *result = 0 ;
78331
78332   arg1 = (Dali::Toolkit::TextField *)jarg1;
78333   arg2 = (Dali::Toolkit::TextField *)jarg2;
78334   if (!arg2) {
78335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
78336     return 0;
78337   }
78338   {
78339     try {
78340       result = (Dali::Toolkit::TextField *) &(arg1)->operator =((Dali::Toolkit::TextField const &)*arg2);
78341     } catch (std::out_of_range& e) {
78342       {
78343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78344       };
78345     } catch (std::exception& e) {
78346       {
78347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78348       };
78349     } catch (...) {
78350       {
78351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78352       };
78353     }
78354   }
78355   jresult = (void *)result;
78356   return jresult;
78357 }
78358
78359
78360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField(void * jarg1) {
78361   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78362
78363   arg1 = (Dali::Toolkit::TextField *)jarg1;
78364   {
78365     try {
78366       delete arg1;
78367     } catch (std::out_of_range& e) {
78368       {
78369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78370       };
78371     } catch (std::exception& e) {
78372       {
78373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78374       };
78375     } catch (...) {
78376       {
78377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78378       };
78379     }
78380   }
78381 }
78382
78383
78384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_DownCast(void * jarg1) {
78385   void * jresult ;
78386   Dali::BaseHandle arg1 ;
78387   Dali::BaseHandle *argp1 ;
78388   Dali::Toolkit::TextField result;
78389
78390   argp1 = (Dali::BaseHandle *)jarg1;
78391   if (!argp1) {
78392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78393     return 0;
78394   }
78395   arg1 = *argp1;
78396   {
78397     try {
78398       result = Dali::Toolkit::TextField::DownCast(arg1);
78399     } catch (std::out_of_range& e) {
78400       {
78401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78402       };
78403     } catch (std::exception& e) {
78404       {
78405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78406       };
78407     } catch (...) {
78408       {
78409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78410       };
78411     }
78412   }
78413   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
78414   return jresult;
78415 }
78416
78417
78418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_TextChangedSignal(void * jarg1) {
78419   void * jresult ;
78420   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78421   Dali::Toolkit::TextField::TextChangedSignalType *result = 0 ;
78422
78423   arg1 = (Dali::Toolkit::TextField *)jarg1;
78424   {
78425     try {
78426       result = (Dali::Toolkit::TextField::TextChangedSignalType *) &(arg1)->TextChangedSignal();
78427     } catch (std::out_of_range& e) {
78428       {
78429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78430       };
78431     } catch (std::exception& e) {
78432       {
78433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78434       };
78435     } catch (...) {
78436       {
78437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78438       };
78439     }
78440   }
78441   jresult = (void *)result;
78442   return jresult;
78443 }
78444
78445
78446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_MaxLengthReachedSignal(void * jarg1) {
78447   void * jresult ;
78448   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78449   Dali::Toolkit::TextField::MaxLengthReachedSignalType *result = 0 ;
78450
78451   arg1 = (Dali::Toolkit::TextField *)jarg1;
78452   {
78453     try {
78454       result = (Dali::Toolkit::TextField::MaxLengthReachedSignalType *) &(arg1)->MaxLengthReachedSignal();
78455     } catch (std::out_of_range& e) {
78456       {
78457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78458       };
78459     } catch (std::exception& e) {
78460       {
78461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78462       };
78463     } catch (...) {
78464       {
78465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78466       };
78467     }
78468   }
78469   jresult = (void *)result;
78470   return jresult;
78471 }
78472
78473
78474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_InputStyleChangedSignal(void * jarg1) {
78475   void * jresult ;
78476   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78477   Dali::Toolkit::TextField::InputStyleChangedSignalType *result = 0 ;
78478
78479   arg1 = (Dali::Toolkit::TextField *)jarg1;
78480   {
78481     try {
78482       result = (Dali::Toolkit::TextField::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
78483     } catch (std::out_of_range& e) {
78484       {
78485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78486       };
78487     } catch (std::exception& e) {
78488       {
78489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78490       };
78491     } catch (...) {
78492       {
78493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78494       };
78495     }
78496   }
78497   jresult = (void *)result;
78498   return jresult;
78499 }
78500
78501
78502 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
78503   int jresult ;
78504   int result;
78505
78506   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
78507   jresult = (int)result;
78508   return jresult;
78509 }
78510
78511
78512 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
78513   int jresult ;
78514   int result;
78515
78516   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
78517   jresult = (int)result;
78518   return jresult;
78519 }
78520
78521
78522 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
78523   int jresult ;
78524   int result;
78525
78526   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
78527   jresult = (int)result;
78528   return jresult;
78529 }
78530
78531
78532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
78533   int jresult ;
78534   int result;
78535
78536   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
78537   jresult = (int)result;
78538   return jresult;
78539 }
78540
78541
78542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
78543   int jresult ;
78544   int result;
78545
78546   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
78547   jresult = (int)result;
78548   return jresult;
78549 }
78550
78551
78552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
78553   int jresult ;
78554   int result;
78555
78556   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
78557   jresult = (int)result;
78558   return jresult;
78559 }
78560
78561
78562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
78563   int jresult ;
78564   int result;
78565
78566   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
78567   jresult = (int)result;
78568   return jresult;
78569 }
78570
78571
78572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
78573   int jresult ;
78574   int result;
78575
78576   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
78577   jresult = (int)result;
78578   return jresult;
78579 }
78580
78581
78582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
78583   int jresult ;
78584   int result;
78585
78586   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
78587   jresult = (int)result;
78588   return jresult;
78589 }
78590
78591
78592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
78593   int jresult ;
78594   int result;
78595
78596   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
78597   jresult = (int)result;
78598   return jresult;
78599 }
78600
78601
78602 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
78603   int jresult ;
78604   int result;
78605
78606   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
78607   jresult = (int)result;
78608   return jresult;
78609 }
78610
78611
78612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
78613   int jresult ;
78614   int result;
78615
78616   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
78617   jresult = (int)result;
78618   return jresult;
78619 }
78620
78621
78622 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
78623   int jresult ;
78624   int result;
78625
78626   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
78627   jresult = (int)result;
78628   return jresult;
78629 }
78630
78631
78632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
78633   int jresult ;
78634   int result;
78635
78636   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
78637   jresult = (int)result;
78638   return jresult;
78639 }
78640
78641
78642 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
78643   int jresult ;
78644   int result;
78645
78646   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
78647   jresult = (int)result;
78648   return jresult;
78649 }
78650
78651
78652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
78653   int jresult ;
78654   int result;
78655
78656   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
78657   jresult = (int)result;
78658   return jresult;
78659 }
78660
78661
78662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
78663   int jresult ;
78664   int result;
78665
78666   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
78667   jresult = (int)result;
78668   return jresult;
78669 }
78670
78671
78672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
78673   int jresult ;
78674   int result;
78675
78676   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
78677   jresult = (int)result;
78678   return jresult;
78679 }
78680
78681
78682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
78683   int jresult ;
78684   int result;
78685
78686   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
78687   jresult = (int)result;
78688   return jresult;
78689 }
78690
78691
78692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
78693   int jresult ;
78694   int result;
78695
78696   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
78697   jresult = (int)result;
78698   return jresult;
78699 }
78700
78701
78702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
78703   int jresult ;
78704   int result;
78705
78706   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
78707   jresult = (int)result;
78708   return jresult;
78709 }
78710
78711
78712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
78713   int jresult ;
78714   int result;
78715
78716   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
78717   jresult = (int)result;
78718   return jresult;
78719 }
78720
78721
78722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
78723   int jresult ;
78724   int result;
78725
78726   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
78727   jresult = (int)result;
78728   return jresult;
78729 }
78730
78731
78732 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
78733   int jresult ;
78734   int result;
78735
78736   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
78737   jresult = (int)result;
78738   return jresult;
78739 }
78740
78741
78742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
78743   void * jresult ;
78744   Dali::Toolkit::TextLabel::Property *result = 0 ;
78745
78746   {
78747     try {
78748       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
78749     } catch (std::out_of_range& e) {
78750       {
78751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78752       };
78753     } catch (std::exception& e) {
78754       {
78755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78756       };
78757     } catch (...) {
78758       {
78759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78760       };
78761     }
78762   }
78763   jresult = (void *)result;
78764   return jresult;
78765 }
78766
78767
78768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
78769   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
78770
78771   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
78772   {
78773     try {
78774       delete arg1;
78775     } catch (std::out_of_range& e) {
78776       {
78777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78778       };
78779     } catch (std::exception& e) {
78780       {
78781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78782       };
78783     } catch (...) {
78784       {
78785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78786       };
78787     }
78788   }
78789 }
78790
78791
78792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
78793   void * jresult ;
78794   Dali::Toolkit::TextLabel result;
78795
78796   {
78797     try {
78798       result = Dali::Toolkit::TextLabel::New();
78799     } catch (std::out_of_range& e) {
78800       {
78801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78802       };
78803     } catch (std::exception& e) {
78804       {
78805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78806       };
78807     } catch (...) {
78808       {
78809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78810       };
78811     }
78812   }
78813   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78814   return jresult;
78815 }
78816
78817
78818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
78819   void * jresult ;
78820   std::string *arg1 = 0 ;
78821   Dali::Toolkit::TextLabel result;
78822
78823   if (!jarg1) {
78824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78825     return 0;
78826   }
78827   std::string arg1_str(jarg1);
78828   arg1 = &arg1_str;
78829   {
78830     try {
78831       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
78832     } catch (std::out_of_range& e) {
78833       {
78834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78835       };
78836     } catch (std::exception& e) {
78837       {
78838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78839       };
78840     } catch (...) {
78841       {
78842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78843       };
78844     }
78845   }
78846   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78847
78848   //argout typemap for const std::string&
78849
78850   return jresult;
78851 }
78852
78853
78854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
78855   void * jresult ;
78856   Dali::Toolkit::TextLabel *result = 0 ;
78857
78858   {
78859     try {
78860       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
78861     } catch (std::out_of_range& e) {
78862       {
78863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78864       };
78865     } catch (std::exception& e) {
78866       {
78867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78868       };
78869     } catch (...) {
78870       {
78871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78872       };
78873     }
78874   }
78875   jresult = (void *)result;
78876   return jresult;
78877 }
78878
78879
78880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
78881   void * jresult ;
78882   Dali::Toolkit::TextLabel *arg1 = 0 ;
78883   Dali::Toolkit::TextLabel *result = 0 ;
78884
78885   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78886   if (!arg1) {
78887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
78888     return 0;
78889   }
78890   {
78891     try {
78892       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
78893     } catch (std::out_of_range& e) {
78894       {
78895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78896       };
78897     } catch (std::exception& e) {
78898       {
78899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78900       };
78901     } catch (...) {
78902       {
78903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78904       };
78905     }
78906   }
78907   jresult = (void *)result;
78908   return jresult;
78909 }
78910
78911
78912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
78913   void * jresult ;
78914   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
78915   Dali::Toolkit::TextLabel *arg2 = 0 ;
78916   Dali::Toolkit::TextLabel *result = 0 ;
78917
78918   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78919   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
78920   if (!arg2) {
78921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
78922     return 0;
78923   }
78924   {
78925     try {
78926       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
78927     } catch (std::out_of_range& e) {
78928       {
78929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78930       };
78931     } catch (std::exception& e) {
78932       {
78933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78934       };
78935     } catch (...) {
78936       {
78937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78938       };
78939     }
78940   }
78941   jresult = (void *)result;
78942   return jresult;
78943 }
78944
78945
78946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
78947   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
78948
78949   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78950   {
78951     try {
78952       delete arg1;
78953     } catch (std::out_of_range& e) {
78954       {
78955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78956       };
78957     } catch (std::exception& e) {
78958       {
78959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78960       };
78961     } catch (...) {
78962       {
78963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78964       };
78965     }
78966   }
78967 }
78968
78969
78970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
78971   void * jresult ;
78972   Dali::BaseHandle arg1 ;
78973   Dali::BaseHandle *argp1 ;
78974   Dali::Toolkit::TextLabel result;
78975
78976   argp1 = (Dali::BaseHandle *)jarg1;
78977   if (!argp1) {
78978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78979     return 0;
78980   }
78981   arg1 = *argp1;
78982   {
78983     try {
78984       result = Dali::Toolkit::TextLabel::DownCast(arg1);
78985     } catch (std::out_of_range& e) {
78986       {
78987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78988       };
78989     } catch (std::exception& e) {
78990       {
78991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78992       };
78993     } catch (...) {
78994       {
78995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78996       };
78997     }
78998   }
78999   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79000   return jresult;
79001 }
79002
79003
79004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
79005   void * jresult ;
79006   Dali::Toolkit::AccessibilityManager *result = 0 ;
79007
79008   {
79009     try {
79010       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
79011     } catch (std::out_of_range& e) {
79012       {
79013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79014       };
79015     } catch (std::exception& e) {
79016       {
79017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79018       };
79019     } catch (...) {
79020       {
79021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79022       };
79023     }
79024   }
79025   jresult = (void *)result;
79026   return jresult;
79027 }
79028
79029
79030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
79031   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79032
79033   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79034   {
79035     try {
79036       delete arg1;
79037     } catch (std::out_of_range& e) {
79038       {
79039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79040       };
79041     } catch (std::exception& e) {
79042       {
79043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79044       };
79045     } catch (...) {
79046       {
79047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79048       };
79049     }
79050   }
79051 }
79052
79053
79054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
79055   void * jresult ;
79056   Dali::Toolkit::AccessibilityManager result;
79057
79058   {
79059     try {
79060       result = Dali::Toolkit::AccessibilityManager::Get();
79061     } catch (std::out_of_range& e) {
79062       {
79063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79064       };
79065     } catch (std::exception& e) {
79066       {
79067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79068       };
79069     } catch (...) {
79070       {
79071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79072       };
79073     }
79074   }
79075   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
79076   return jresult;
79077 }
79078
79079
79080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
79081   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79082   Dali::Actor arg2 ;
79083   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79084   std::string *arg4 = 0 ;
79085   Dali::Actor *argp2 ;
79086
79087   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79088   argp2 = (Dali::Actor *)jarg2;
79089   if (!argp2) {
79090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79091     return ;
79092   }
79093   arg2 = *argp2;
79094   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79095   if (!jarg4) {
79096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79097     return ;
79098   }
79099   std::string arg4_str(jarg4);
79100   arg4 = &arg4_str;
79101   {
79102     try {
79103       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
79104     } catch (std::out_of_range& e) {
79105       {
79106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79107       };
79108     } catch (std::exception& e) {
79109       {
79110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79111       };
79112     } catch (...) {
79113       {
79114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79115       };
79116     }
79117   }
79118
79119   //argout typemap for const std::string&
79120
79121 }
79122
79123
79124 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
79125   char * jresult ;
79126   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79127   Dali::Actor arg2 ;
79128   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79129   Dali::Actor *argp2 ;
79130   std::string result;
79131
79132   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79133   argp2 = (Dali::Actor *)jarg2;
79134   if (!argp2) {
79135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79136     return 0;
79137   }
79138   arg2 = *argp2;
79139   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79140   {
79141     try {
79142       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
79143     } catch (std::out_of_range& e) {
79144       {
79145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79146       };
79147     } catch (std::exception& e) {
79148       {
79149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79150       };
79151     } catch (...) {
79152       {
79153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79154       };
79155     }
79156   }
79157   jresult = SWIG_csharp_string_callback((&result)->c_str());
79158   return jresult;
79159 }
79160
79161
79162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
79163   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79164   Dali::Actor arg2 ;
79165   unsigned int arg3 ;
79166   Dali::Actor *argp2 ;
79167
79168   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79169   argp2 = (Dali::Actor *)jarg2;
79170   if (!argp2) {
79171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79172     return ;
79173   }
79174   arg2 = *argp2;
79175   arg3 = (unsigned int)jarg3;
79176   {
79177     try {
79178       (arg1)->SetFocusOrder(arg2,arg3);
79179     } catch (std::out_of_range& e) {
79180       {
79181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79182       };
79183     } catch (std::exception& e) {
79184       {
79185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79186       };
79187     } catch (...) {
79188       {
79189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79190       };
79191     }
79192   }
79193 }
79194
79195
79196 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
79197   unsigned int jresult ;
79198   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79199   Dali::Actor arg2 ;
79200   Dali::Actor *argp2 ;
79201   unsigned int result;
79202
79203   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79204   argp2 = (Dali::Actor *)jarg2;
79205   if (!argp2) {
79206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79207     return 0;
79208   }
79209   arg2 = *argp2;
79210   {
79211     try {
79212       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
79213     } catch (std::out_of_range& e) {
79214       {
79215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79216       };
79217     } catch (std::exception& e) {
79218       {
79219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79220       };
79221     } catch (...) {
79222       {
79223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79224       };
79225     }
79226   }
79227   jresult = result;
79228   return jresult;
79229 }
79230
79231
79232 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
79233   unsigned int jresult ;
79234   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79235   unsigned int result;
79236
79237   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79238   {
79239     try {
79240       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
79241     } catch (std::out_of_range& e) {
79242       {
79243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79244       };
79245     } catch (std::exception& e) {
79246       {
79247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79248       };
79249     } catch (...) {
79250       {
79251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79252       };
79253     }
79254   }
79255   jresult = result;
79256   return jresult;
79257 }
79258
79259
79260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
79261   void * jresult ;
79262   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79263   unsigned int arg2 ;
79264   Dali::Actor result;
79265
79266   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79267   arg2 = (unsigned int)jarg2;
79268   {
79269     try {
79270       result = (arg1)->GetActorByFocusOrder(arg2);
79271     } catch (std::out_of_range& e) {
79272       {
79273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79274       };
79275     } catch (std::exception& e) {
79276       {
79277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79278       };
79279     } catch (...) {
79280       {
79281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79282       };
79283     }
79284   }
79285   jresult = new Dali::Actor((const Dali::Actor &)result);
79286   return jresult;
79287 }
79288
79289
79290 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
79291   unsigned int jresult ;
79292   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79293   Dali::Actor arg2 ;
79294   Dali::Actor *argp2 ;
79295   bool result;
79296
79297   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79298   argp2 = (Dali::Actor *)jarg2;
79299   if (!argp2) {
79300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79301     return 0;
79302   }
79303   arg2 = *argp2;
79304   {
79305     try {
79306       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
79307     } catch (std::out_of_range& e) {
79308       {
79309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79310       };
79311     } catch (std::exception& e) {
79312       {
79313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79314       };
79315     } catch (...) {
79316       {
79317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79318       };
79319     }
79320   }
79321   jresult = result;
79322   return jresult;
79323 }
79324
79325
79326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
79327   void * jresult ;
79328   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79329   Dali::Actor result;
79330
79331   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79332   {
79333     try {
79334       result = (arg1)->GetCurrentFocusActor();
79335     } catch (std::out_of_range& e) {
79336       {
79337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79338       };
79339     } catch (std::exception& e) {
79340       {
79341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79342       };
79343     } catch (...) {
79344       {
79345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79346       };
79347     }
79348   }
79349   jresult = new Dali::Actor((const Dali::Actor &)result);
79350   return jresult;
79351 }
79352
79353
79354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
79355   void * jresult ;
79356   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79357   Dali::Actor result;
79358
79359   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79360   {
79361     try {
79362       result = (arg1)->GetCurrentFocusGroup();
79363     } catch (std::out_of_range& e) {
79364       {
79365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79366       };
79367     } catch (std::exception& e) {
79368       {
79369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79370       };
79371     } catch (...) {
79372       {
79373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79374       };
79375     }
79376   }
79377   jresult = new Dali::Actor((const Dali::Actor &)result);
79378   return jresult;
79379 }
79380
79381
79382 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
79383   unsigned int jresult ;
79384   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79385   unsigned int result;
79386
79387   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79388   {
79389     try {
79390       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
79391     } catch (std::out_of_range& e) {
79392       {
79393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79394       };
79395     } catch (std::exception& e) {
79396       {
79397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79398       };
79399     } catch (...) {
79400       {
79401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79402       };
79403     }
79404   }
79405   jresult = result;
79406   return jresult;
79407 }
79408
79409
79410 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
79411   unsigned int jresult ;
79412   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79413   bool result;
79414
79415   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79416   {
79417     try {
79418       result = (bool)(arg1)->MoveFocusForward();
79419     } catch (std::out_of_range& e) {
79420       {
79421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79422       };
79423     } catch (std::exception& e) {
79424       {
79425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79426       };
79427     } catch (...) {
79428       {
79429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79430       };
79431     }
79432   }
79433   jresult = result;
79434   return jresult;
79435 }
79436
79437
79438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
79439   unsigned int jresult ;
79440   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79441   bool result;
79442
79443   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79444   {
79445     try {
79446       result = (bool)(arg1)->MoveFocusBackward();
79447     } catch (std::out_of_range& e) {
79448       {
79449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79450       };
79451     } catch (std::exception& e) {
79452       {
79453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79454       };
79455     } catch (...) {
79456       {
79457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79458       };
79459     }
79460   }
79461   jresult = result;
79462   return jresult;
79463 }
79464
79465
79466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
79467   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79468
79469   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79470   {
79471     try {
79472       (arg1)->ClearFocus();
79473     } catch (std::out_of_range& e) {
79474       {
79475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79476       };
79477     } catch (std::exception& e) {
79478       {
79479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79480       };
79481     } catch (...) {
79482       {
79483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79484       };
79485     }
79486   }
79487 }
79488
79489
79490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
79491   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79492
79493   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79494   {
79495     try {
79496       (arg1)->Reset();
79497     } catch (std::out_of_range& e) {
79498       {
79499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79500       };
79501     } catch (std::exception& e) {
79502       {
79503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79504       };
79505     } catch (...) {
79506       {
79507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79508       };
79509     }
79510   }
79511 }
79512
79513
79514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
79515   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79516   Dali::Actor arg2 ;
79517   bool arg3 ;
79518   Dali::Actor *argp2 ;
79519
79520   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79521   argp2 = (Dali::Actor *)jarg2;
79522   if (!argp2) {
79523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79524     return ;
79525   }
79526   arg2 = *argp2;
79527   arg3 = jarg3 ? true : false;
79528   {
79529     try {
79530       (arg1)->SetFocusGroup(arg2,arg3);
79531     } catch (std::out_of_range& e) {
79532       {
79533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79534       };
79535     } catch (std::exception& e) {
79536       {
79537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79538       };
79539     } catch (...) {
79540       {
79541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79542       };
79543     }
79544   }
79545 }
79546
79547
79548 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
79549   unsigned int jresult ;
79550   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79551   Dali::Actor arg2 ;
79552   Dali::Actor *argp2 ;
79553   bool result;
79554
79555   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79556   argp2 = (Dali::Actor *)jarg2;
79557   if (!argp2) {
79558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79559     return 0;
79560   }
79561   arg2 = *argp2;
79562   {
79563     try {
79564       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
79565     } catch (std::out_of_range& e) {
79566       {
79567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79568       };
79569     } catch (std::exception& e) {
79570       {
79571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79572       };
79573     } catch (...) {
79574       {
79575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79576       };
79577     }
79578   }
79579   jresult = result;
79580   return jresult;
79581 }
79582
79583
79584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
79585   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79586   bool arg2 ;
79587
79588   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79589   arg2 = jarg2 ? true : false;
79590   {
79591     try {
79592       (arg1)->SetGroupMode(arg2);
79593     } catch (std::out_of_range& e) {
79594       {
79595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79596       };
79597     } catch (std::exception& e) {
79598       {
79599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79600       };
79601     } catch (...) {
79602       {
79603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79604       };
79605     }
79606   }
79607 }
79608
79609
79610 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
79611   unsigned int jresult ;
79612   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79613   bool result;
79614
79615   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79616   {
79617     try {
79618       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
79619     } catch (std::out_of_range& e) {
79620       {
79621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79622       };
79623     } catch (std::exception& e) {
79624       {
79625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79626       };
79627     } catch (...) {
79628       {
79629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79630       };
79631     }
79632   }
79633   jresult = result;
79634   return jresult;
79635 }
79636
79637
79638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
79639   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79640   bool arg2 ;
79641
79642   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79643   arg2 = jarg2 ? true : false;
79644   {
79645     try {
79646       (arg1)->SetWrapMode(arg2);
79647     } catch (std::out_of_range& e) {
79648       {
79649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79650       };
79651     } catch (std::exception& e) {
79652       {
79653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79654       };
79655     } catch (...) {
79656       {
79657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79658       };
79659     }
79660   }
79661 }
79662
79663
79664 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
79665   unsigned int jresult ;
79666   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79667   bool result;
79668
79669   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79670   {
79671     try {
79672       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
79673     } catch (std::out_of_range& e) {
79674       {
79675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79676       };
79677     } catch (std::exception& e) {
79678       {
79679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79680       };
79681     } catch (...) {
79682       {
79683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79684       };
79685     }
79686   }
79687   jresult = result;
79688   return jresult;
79689 }
79690
79691
79692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
79693   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79694   Dali::Actor arg2 ;
79695   Dali::Actor *argp2 ;
79696
79697   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79698   argp2 = (Dali::Actor *)jarg2;
79699   if (!argp2) {
79700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79701     return ;
79702   }
79703   arg2 = *argp2;
79704   {
79705     try {
79706       (arg1)->SetFocusIndicatorActor(arg2);
79707     } catch (std::out_of_range& e) {
79708       {
79709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79710       };
79711     } catch (std::exception& e) {
79712       {
79713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79714       };
79715     } catch (...) {
79716       {
79717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79718       };
79719     }
79720   }
79721 }
79722
79723
79724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
79725   void * jresult ;
79726   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79727   Dali::Actor result;
79728
79729   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79730   {
79731     try {
79732       result = (arg1)->GetFocusIndicatorActor();
79733     } catch (std::out_of_range& e) {
79734       {
79735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79736       };
79737     } catch (std::exception& e) {
79738       {
79739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79740       };
79741     } catch (...) {
79742       {
79743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79744       };
79745     }
79746   }
79747   jresult = new Dali::Actor((const Dali::Actor &)result);
79748   return jresult;
79749 }
79750
79751
79752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
79753   void * jresult ;
79754   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79755   Dali::Actor arg2 ;
79756   Dali::Actor *argp2 ;
79757   Dali::Actor result;
79758
79759   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79760   argp2 = (Dali::Actor *)jarg2;
79761   if (!argp2) {
79762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79763     return 0;
79764   }
79765   arg2 = *argp2;
79766   {
79767     try {
79768       result = (arg1)->GetFocusGroup(arg2);
79769     } catch (std::out_of_range& e) {
79770       {
79771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79772       };
79773     } catch (std::exception& e) {
79774       {
79775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79776       };
79777     } catch (...) {
79778       {
79779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79780       };
79781     }
79782   }
79783   jresult = new Dali::Actor((const Dali::Actor &)result);
79784   return jresult;
79785 }
79786
79787
79788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
79789   void * jresult ;
79790   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79791   Dali::Vector2 result;
79792
79793   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79794   {
79795     try {
79796       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
79797     } catch (std::out_of_range& e) {
79798       {
79799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79800       };
79801     } catch (std::exception& e) {
79802       {
79803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79804       };
79805     } catch (...) {
79806       {
79807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79808       };
79809     }
79810   }
79811   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
79812   return jresult;
79813 }
79814
79815
79816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
79817   void * jresult ;
79818   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79819   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
79820
79821   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79822   {
79823     try {
79824       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
79825     } catch (std::out_of_range& e) {
79826       {
79827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79828       };
79829     } catch (std::exception& e) {
79830       {
79831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79832       };
79833     } catch (...) {
79834       {
79835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79836       };
79837     }
79838   }
79839   jresult = (void *)result;
79840   return jresult;
79841 }
79842
79843
79844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
79845   void * jresult ;
79846   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79847   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
79848
79849   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79850   {
79851     try {
79852       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
79853     } catch (std::out_of_range& e) {
79854       {
79855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79856       };
79857     } catch (std::exception& e) {
79858       {
79859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79860       };
79861     } catch (...) {
79862       {
79863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79864       };
79865     }
79866   }
79867   jresult = (void *)result;
79868   return jresult;
79869 }
79870
79871
79872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
79873   void * jresult ;
79874   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79875   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
79876
79877   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79878   {
79879     try {
79880       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
79881     } catch (std::out_of_range& e) {
79882       {
79883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79884       };
79885     } catch (std::exception& e) {
79886       {
79887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79888       };
79889     } catch (...) {
79890       {
79891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79892       };
79893     }
79894   }
79895   jresult = (void *)result;
79896   return jresult;
79897 }
79898
79899
79900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
79901   void * jresult ;
79902   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79903   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79904
79905   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79906   {
79907     try {
79908       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
79909     } catch (std::out_of_range& e) {
79910       {
79911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79912       };
79913     } catch (std::exception& e) {
79914       {
79915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79916       };
79917     } catch (...) {
79918       {
79919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79920       };
79921     }
79922   }
79923   jresult = (void *)result;
79924   return jresult;
79925 }
79926
79927
79928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
79929   void * jresult ;
79930   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79931   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79932
79933   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79934   {
79935     try {
79936       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
79937     } catch (std::out_of_range& e) {
79938       {
79939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79940       };
79941     } catch (std::exception& e) {
79942       {
79943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79944       };
79945     } catch (...) {
79946       {
79947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79948       };
79949     }
79950   }
79951   jresult = (void *)result;
79952   return jresult;
79953 }
79954
79955
79956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
79957   void * jresult ;
79958   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79959   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79960
79961   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79962   {
79963     try {
79964       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
79965     } catch (std::out_of_range& e) {
79966       {
79967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79968       };
79969     } catch (std::exception& e) {
79970       {
79971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79972       };
79973     } catch (...) {
79974       {
79975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79976       };
79977     }
79978   }
79979   jresult = (void *)result;
79980   return jresult;
79981 }
79982
79983
79984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
79985   void * jresult ;
79986   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79987   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79988
79989   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79990   {
79991     try {
79992       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
79993     } catch (std::out_of_range& e) {
79994       {
79995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79996       };
79997     } catch (std::exception& e) {
79998       {
79999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80000       };
80001     } catch (...) {
80002       {
80003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80004       };
80005     }
80006   }
80007   jresult = (void *)result;
80008   return jresult;
80009 }
80010
80011
80012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
80013   void * jresult ;
80014   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80015   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80016
80017   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80018   {
80019     try {
80020       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
80021     } catch (std::out_of_range& e) {
80022       {
80023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80024       };
80025     } catch (std::exception& e) {
80026       {
80027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80028       };
80029     } catch (...) {
80030       {
80031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80032       };
80033     }
80034   }
80035   jresult = (void *)result;
80036   return jresult;
80037 }
80038
80039
80040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
80041   void * jresult ;
80042   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80043   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80044
80045   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80046   {
80047     try {
80048       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
80049     } catch (std::out_of_range& e) {
80050       {
80051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80052       };
80053     } catch (std::exception& e) {
80054       {
80055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80056       };
80057     } catch (...) {
80058       {
80059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80060       };
80061     }
80062   }
80063   jresult = (void *)result;
80064   return jresult;
80065 }
80066
80067
80068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
80069   void * jresult ;
80070   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80071   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80072
80073   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80074   {
80075     try {
80076       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
80077     } catch (std::out_of_range& e) {
80078       {
80079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80080       };
80081     } catch (std::exception& e) {
80082       {
80083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80084       };
80085     } catch (...) {
80086       {
80087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80088       };
80089     }
80090   }
80091   jresult = (void *)result;
80092   return jresult;
80093 }
80094
80095
80096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
80097   void * jresult ;
80098   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80099   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80100
80101   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80102   {
80103     try {
80104       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
80105     } catch (std::out_of_range& e) {
80106       {
80107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80108       };
80109     } catch (std::exception& e) {
80110       {
80111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80112       };
80113     } catch (...) {
80114       {
80115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80116       };
80117     }
80118   }
80119   jresult = (void *)result;
80120   return jresult;
80121 }
80122
80123
80124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
80125   void * jresult ;
80126   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80127   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80128
80129   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80130   {
80131     try {
80132       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
80133     } catch (std::out_of_range& e) {
80134       {
80135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80136       };
80137     } catch (std::exception& e) {
80138       {
80139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80140       };
80141     } catch (...) {
80142       {
80143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80144       };
80145     }
80146   }
80147   jresult = (void *)result;
80148   return jresult;
80149 }
80150
80151
80152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
80153   void * jresult ;
80154   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80155   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80156
80157   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80158   {
80159     try {
80160       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
80161     } catch (std::out_of_range& e) {
80162       {
80163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80164       };
80165     } catch (std::exception& e) {
80166       {
80167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80168       };
80169     } catch (...) {
80170       {
80171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80172       };
80173     }
80174   }
80175   jresult = (void *)result;
80176   return jresult;
80177 }
80178
80179
80180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
80181   void * jresult ;
80182   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80183   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80184
80185   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80186   {
80187     try {
80188       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
80189     } catch (std::out_of_range& e) {
80190       {
80191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80192       };
80193     } catch (std::exception& e) {
80194       {
80195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80196       };
80197     } catch (...) {
80198       {
80199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80200       };
80201     }
80202   }
80203   jresult = (void *)result;
80204   return jresult;
80205 }
80206
80207
80208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
80209   void * jresult ;
80210   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80211   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80212
80213   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80214   {
80215     try {
80216       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
80217     } catch (std::out_of_range& e) {
80218       {
80219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80220       };
80221     } catch (std::exception& e) {
80222       {
80223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80224       };
80225     } catch (...) {
80226       {
80227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80228       };
80229     }
80230   }
80231   jresult = (void *)result;
80232   return jresult;
80233 }
80234
80235
80236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
80237   void * jresult ;
80238   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80239   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80240
80241   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80242   {
80243     try {
80244       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
80245     } catch (std::out_of_range& e) {
80246       {
80247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80248       };
80249     } catch (std::exception& e) {
80250       {
80251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80252       };
80253     } catch (...) {
80254       {
80255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80256       };
80257     }
80258   }
80259   jresult = (void *)result;
80260   return jresult;
80261 }
80262
80263
80264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
80265   void * jresult ;
80266   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80267   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80268
80269   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80270   {
80271     try {
80272       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
80273     } catch (std::out_of_range& e) {
80274       {
80275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80276       };
80277     } catch (std::exception& e) {
80278       {
80279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80280       };
80281     } catch (...) {
80282       {
80283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80284       };
80285     }
80286   }
80287   jresult = (void *)result;
80288   return jresult;
80289 }
80290
80291
80292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
80293   void * jresult ;
80294   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80295   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80296
80297   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80298   {
80299     try {
80300       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
80301     } catch (std::out_of_range& e) {
80302       {
80303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80304       };
80305     } catch (std::exception& e) {
80306       {
80307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80308       };
80309     } catch (...) {
80310       {
80311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80312       };
80313     }
80314   }
80315   jresult = (void *)result;
80316   return jresult;
80317 }
80318
80319
80320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
80321   void * jresult ;
80322   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80323   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80324
80325   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80326   {
80327     try {
80328       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
80329     } catch (std::out_of_range& e) {
80330       {
80331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80332       };
80333     } catch (std::exception& e) {
80334       {
80335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80336       };
80337     } catch (...) {
80338       {
80339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80340       };
80341     }
80342   }
80343   jresult = (void *)result;
80344   return jresult;
80345 }
80346
80347
80348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
80349   void * jresult ;
80350   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80351   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80352
80353   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80354   {
80355     try {
80356       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
80357     } catch (std::out_of_range& e) {
80358       {
80359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80360       };
80361     } catch (std::exception& e) {
80362       {
80363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80364       };
80365     } catch (...) {
80366       {
80367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80368       };
80369     }
80370   }
80371   jresult = (void *)result;
80372   return jresult;
80373 }
80374
80375
80376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
80377   void * jresult ;
80378   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80379   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80380
80381   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80382   {
80383     try {
80384       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
80385     } catch (std::out_of_range& e) {
80386       {
80387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80388       };
80389     } catch (std::exception& e) {
80390       {
80391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80392       };
80393     } catch (...) {
80394       {
80395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80396       };
80397     }
80398   }
80399   jresult = (void *)result;
80400   return jresult;
80401 }
80402
80403
80404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
80405   void * jresult ;
80406   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80407   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80408
80409   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80410   {
80411     try {
80412       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
80413     } catch (std::out_of_range& e) {
80414       {
80415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80416       };
80417     } catch (std::exception& e) {
80418       {
80419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80420       };
80421     } catch (...) {
80422       {
80423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80424       };
80425     }
80426   }
80427   jresult = (void *)result;
80428   return jresult;
80429 }
80430
80431
80432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
80433   void * jresult ;
80434   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80435   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80436
80437   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80438   {
80439     try {
80440       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
80441     } catch (std::out_of_range& e) {
80442       {
80443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80444       };
80445     } catch (std::exception& e) {
80446       {
80447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80448       };
80449     } catch (...) {
80450       {
80451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80452       };
80453     }
80454   }
80455   jresult = (void *)result;
80456   return jresult;
80457 }
80458
80459
80460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
80461   void * jresult ;
80462   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80463   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80464
80465   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80466   {
80467     try {
80468       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
80469     } catch (std::out_of_range& e) {
80470       {
80471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80472       };
80473     } catch (std::exception& e) {
80474       {
80475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80476       };
80477     } catch (...) {
80478       {
80479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80480       };
80481     }
80482   }
80483   jresult = (void *)result;
80484   return jresult;
80485 }
80486
80487
80488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
80489   void * jresult ;
80490   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80491   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80492
80493   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80494   {
80495     try {
80496       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
80497     } catch (std::out_of_range& e) {
80498       {
80499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80500       };
80501     } catch (std::exception& e) {
80502       {
80503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80504       };
80505     } catch (...) {
80506       {
80507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80508       };
80509     }
80510   }
80511   jresult = (void *)result;
80512   return jresult;
80513 }
80514
80515
80516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
80517   void * jresult ;
80518   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80519   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80520
80521   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80522   {
80523     try {
80524       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
80525     } catch (std::out_of_range& e) {
80526       {
80527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80528       };
80529     } catch (std::exception& e) {
80530       {
80531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80532       };
80533     } catch (...) {
80534       {
80535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80536       };
80537     }
80538   }
80539   jresult = (void *)result;
80540   return jresult;
80541 }
80542
80543
80544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
80545   void * jresult ;
80546   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80547   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80548
80549   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80550   {
80551     try {
80552       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
80553     } catch (std::out_of_range& e) {
80554       {
80555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80556       };
80557     } catch (std::exception& e) {
80558       {
80559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80560       };
80561     } catch (...) {
80562       {
80563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80564       };
80565     }
80566   }
80567   jresult = (void *)result;
80568   return jresult;
80569 }
80570
80571
80572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
80573   void * jresult ;
80574   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80575   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80576
80577   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80578   {
80579     try {
80580       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
80581     } catch (std::out_of_range& e) {
80582       {
80583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80584       };
80585     } catch (std::exception& e) {
80586       {
80587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80588       };
80589     } catch (...) {
80590       {
80591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80592       };
80593     }
80594   }
80595   jresult = (void *)result;
80596   return jresult;
80597 }
80598
80599
80600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
80601   void * jresult ;
80602   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80603   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80604
80605   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80606   {
80607     try {
80608       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
80609     } catch (std::out_of_range& e) {
80610       {
80611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80612       };
80613     } catch (std::exception& e) {
80614       {
80615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80616       };
80617     } catch (...) {
80618       {
80619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80620       };
80621     }
80622   }
80623   jresult = (void *)result;
80624   return jresult;
80625 }
80626
80627
80628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
80629   void * jresult ;
80630   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80631   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
80632
80633   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80634   {
80635     try {
80636       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
80637     } catch (std::out_of_range& e) {
80638       {
80639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80640       };
80641     } catch (std::exception& e) {
80642       {
80643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80644       };
80645     } catch (...) {
80646       {
80647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80648       };
80649     }
80650   }
80651   jresult = (void *)result;
80652   return jresult;
80653 }
80654
80655
80656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
80657   void * jresult ;
80658   Dali::Toolkit::StyleManager *result = 0 ;
80659
80660   {
80661     try {
80662       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
80663     } catch (std::out_of_range& e) {
80664       {
80665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80666       };
80667     } catch (std::exception& e) {
80668       {
80669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80670       };
80671     } catch (...) {
80672       {
80673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80674       };
80675     }
80676   }
80677   jresult = (void *)result;
80678   return jresult;
80679 }
80680
80681
80682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
80683   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80684
80685   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80686   {
80687     try {
80688       delete arg1;
80689     } catch (std::out_of_range& e) {
80690       {
80691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80692       };
80693     } catch (std::exception& e) {
80694       {
80695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80696       };
80697     } catch (...) {
80698       {
80699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80700       };
80701     }
80702   }
80703 }
80704
80705
80706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
80707   void * jresult ;
80708   Dali::Toolkit::StyleManager result;
80709
80710   {
80711     try {
80712       result = Dali::Toolkit::StyleManager::Get();
80713     } catch (std::out_of_range& e) {
80714       {
80715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80716       };
80717     } catch (std::exception& e) {
80718       {
80719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80720       };
80721     } catch (...) {
80722       {
80723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80724       };
80725     }
80726   }
80727   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
80728   return jresult;
80729 }
80730
80731
80732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
80733   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80734   std::string *arg2 = 0 ;
80735
80736   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80737   if (!jarg2) {
80738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80739     return ;
80740   }
80741   std::string arg2_str(jarg2);
80742   arg2 = &arg2_str;
80743   {
80744     try {
80745       (arg1)->ApplyTheme((std::string const &)*arg2);
80746     } catch (std::out_of_range& e) {
80747       {
80748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80749       };
80750     } catch (std::exception& e) {
80751       {
80752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80753       };
80754     } catch (...) {
80755       {
80756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80757       };
80758     }
80759   }
80760
80761   //argout typemap for const std::string&
80762
80763 }
80764
80765
80766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
80767   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80768
80769   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80770   {
80771     try {
80772       (arg1)->ApplyDefaultTheme();
80773     } catch (std::out_of_range& e) {
80774       {
80775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80776       };
80777     } catch (std::exception& e) {
80778       {
80779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80780       };
80781     } catch (...) {
80782       {
80783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80784       };
80785     }
80786   }
80787 }
80788
80789
80790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
80791   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80792   std::string *arg2 = 0 ;
80793   Dali::Property::Value *arg3 = 0 ;
80794
80795   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80796   if (!jarg2) {
80797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80798     return ;
80799   }
80800   std::string arg2_str(jarg2);
80801   arg2 = &arg2_str;
80802   arg3 = (Dali::Property::Value *)jarg3;
80803   if (!arg3) {
80804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
80805     return ;
80806   }
80807   {
80808     try {
80809       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
80810     } catch (std::out_of_range& e) {
80811       {
80812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80813       };
80814     } catch (std::exception& e) {
80815       {
80816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80817       };
80818     } catch (...) {
80819       {
80820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80821       };
80822     }
80823   }
80824
80825   //argout typemap for const std::string&
80826
80827 }
80828
80829
80830 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
80831   unsigned int jresult ;
80832   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80833   std::string *arg2 = 0 ;
80834   Dali::Property::Value *arg3 = 0 ;
80835   bool result;
80836
80837   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80838   if (!jarg2) {
80839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80840     return 0;
80841   }
80842   std::string arg2_str(jarg2);
80843   arg2 = &arg2_str;
80844   arg3 = (Dali::Property::Value *)jarg3;
80845   if (!arg3) {
80846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
80847     return 0;
80848   }
80849   {
80850     try {
80851       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
80852     } catch (std::out_of_range& e) {
80853       {
80854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80855       };
80856     } catch (std::exception& e) {
80857       {
80858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80859       };
80860     } catch (...) {
80861       {
80862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80863       };
80864     }
80865   }
80866   jresult = result;
80867
80868   //argout typemap for const std::string&
80869
80870   return jresult;
80871 }
80872
80873
80874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
80875   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80876   Dali::Toolkit::Control arg2 ;
80877   std::string *arg3 = 0 ;
80878   std::string *arg4 = 0 ;
80879   Dali::Toolkit::Control *argp2 ;
80880
80881   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80882   argp2 = (Dali::Toolkit::Control *)jarg2;
80883   if (!argp2) {
80884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
80885     return ;
80886   }
80887   arg2 = *argp2;
80888   if (!jarg3) {
80889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80890     return ;
80891   }
80892   std::string arg3_str(jarg3);
80893   arg3 = &arg3_str;
80894   if (!jarg4) {
80895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80896     return ;
80897   }
80898   std::string arg4_str(jarg4);
80899   arg4 = &arg4_str;
80900   {
80901     try {
80902       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
80903     } catch (std::out_of_range& e) {
80904       {
80905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80906       };
80907     } catch (std::exception& e) {
80908       {
80909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80910       };
80911     } catch (...) {
80912       {
80913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80914       };
80915     }
80916   }
80917
80918   //argout typemap for const std::string&
80919
80920
80921   //argout typemap for const std::string&
80922
80923 }
80924
80925
80926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
80927   void * jresult ;
80928   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80929   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
80930
80931   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80932   {
80933     try {
80934       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
80935     } catch (std::out_of_range& e) {
80936       {
80937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80938       };
80939     } catch (std::exception& e) {
80940       {
80941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80942       };
80943     } catch (...) {
80944       {
80945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80946       };
80947     }
80948   }
80949   jresult = (void *)result;
80950   return jresult;
80951 }
80952
80953
80954 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
80955   int jresult ;
80956   int result;
80957
80958   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
80959   jresult = (int)result;
80960   return jresult;
80961 }
80962
80963
80964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
80965   int jresult ;
80966   int result;
80967
80968   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
80969   jresult = (int)result;
80970   return jresult;
80971 }
80972
80973
80974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
80975   int jresult ;
80976   int result;
80977
80978   result = (int)Dali::Toolkit::Slider::Property::VALUE;
80979   jresult = (int)result;
80980   return jresult;
80981 }
80982
80983
80984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
80985   int jresult ;
80986   int result;
80987
80988   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
80989   jresult = (int)result;
80990   return jresult;
80991 }
80992
80993
80994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
80995   int jresult ;
80996   int result;
80997
80998   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
80999   jresult = (int)result;
81000   return jresult;
81001 }
81002
81003
81004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
81005   int jresult ;
81006   int result;
81007
81008   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
81009   jresult = (int)result;
81010   return jresult;
81011 }
81012
81013
81014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
81015   int jresult ;
81016   int result;
81017
81018   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
81019   jresult = (int)result;
81020   return jresult;
81021 }
81022
81023
81024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
81025   int jresult ;
81026   int result;
81027
81028   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
81029   jresult = (int)result;
81030   return jresult;
81031 }
81032
81033
81034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
81035   int jresult ;
81036   int result;
81037
81038   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
81039   jresult = (int)result;
81040   return jresult;
81041 }
81042
81043
81044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
81045   int jresult ;
81046   int result;
81047
81048   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
81049   jresult = (int)result;
81050   return jresult;
81051 }
81052
81053
81054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
81055   int jresult ;
81056   int result;
81057
81058   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
81059   jresult = (int)result;
81060   return jresult;
81061 }
81062
81063
81064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
81065   int jresult ;
81066   int result;
81067
81068   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
81069   jresult = (int)result;
81070   return jresult;
81071 }
81072
81073
81074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
81075   int jresult ;
81076   int result;
81077
81078   result = (int)Dali::Toolkit::Slider::Property::MARKS;
81079   jresult = (int)result;
81080   return jresult;
81081 }
81082
81083
81084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
81085   int jresult ;
81086   int result;
81087
81088   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
81089   jresult = (int)result;
81090   return jresult;
81091 }
81092
81093
81094 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
81095   int jresult ;
81096   int result;
81097
81098   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
81099   jresult = (int)result;
81100   return jresult;
81101 }
81102
81103
81104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
81105   void * jresult ;
81106   Dali::Toolkit::Slider::Property *result = 0 ;
81107
81108   {
81109     try {
81110       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
81111     } catch (std::out_of_range& e) {
81112       {
81113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81114       };
81115     } catch (std::exception& e) {
81116       {
81117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81118       };
81119     } catch (...) {
81120       {
81121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81122       };
81123     }
81124   }
81125   jresult = (void *)result;
81126   return jresult;
81127 }
81128
81129
81130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
81131   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
81132
81133   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
81134   {
81135     try {
81136       delete arg1;
81137     } catch (std::out_of_range& e) {
81138       {
81139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81140       };
81141     } catch (std::exception& e) {
81142       {
81143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81144       };
81145     } catch (...) {
81146       {
81147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81148       };
81149     }
81150   }
81151 }
81152
81153
81154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
81155   void * jresult ;
81156   Dali::Toolkit::Slider result;
81157
81158   {
81159     try {
81160       result = Dali::Toolkit::Slider::New();
81161     } catch (std::out_of_range& e) {
81162       {
81163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81164       };
81165     } catch (std::exception& e) {
81166       {
81167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81168       };
81169     } catch (...) {
81170       {
81171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81172       };
81173     }
81174   }
81175   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81176   return jresult;
81177 }
81178
81179
81180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
81181   void * jresult ;
81182   Dali::Toolkit::Slider *result = 0 ;
81183
81184   {
81185     try {
81186       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
81187     } catch (std::out_of_range& e) {
81188       {
81189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81190       };
81191     } catch (std::exception& e) {
81192       {
81193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81194       };
81195     } catch (...) {
81196       {
81197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81198       };
81199     }
81200   }
81201   jresult = (void *)result;
81202   return jresult;
81203 }
81204
81205
81206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
81207   void * jresult ;
81208   Dali::Toolkit::Slider *arg1 = 0 ;
81209   Dali::Toolkit::Slider *result = 0 ;
81210
81211   arg1 = (Dali::Toolkit::Slider *)jarg1;
81212   if (!arg1) {
81213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
81214     return 0;
81215   }
81216   {
81217     try {
81218       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
81219     } catch (std::out_of_range& e) {
81220       {
81221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81222       };
81223     } catch (std::exception& e) {
81224       {
81225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81226       };
81227     } catch (...) {
81228       {
81229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81230       };
81231     }
81232   }
81233   jresult = (void *)result;
81234   return jresult;
81235 }
81236
81237
81238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
81239   void * jresult ;
81240   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81241   Dali::Toolkit::Slider *arg2 = 0 ;
81242   Dali::Toolkit::Slider *result = 0 ;
81243
81244   arg1 = (Dali::Toolkit::Slider *)jarg1;
81245   arg2 = (Dali::Toolkit::Slider *)jarg2;
81246   if (!arg2) {
81247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
81248     return 0;
81249   }
81250   {
81251     try {
81252       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
81253     } catch (std::out_of_range& e) {
81254       {
81255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81256       };
81257     } catch (std::exception& e) {
81258       {
81259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81260       };
81261     } catch (...) {
81262       {
81263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81264       };
81265     }
81266   }
81267   jresult = (void *)result;
81268   return jresult;
81269 }
81270
81271
81272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
81273   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81274
81275   arg1 = (Dali::Toolkit::Slider *)jarg1;
81276   {
81277     try {
81278       delete arg1;
81279     } catch (std::out_of_range& e) {
81280       {
81281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81282       };
81283     } catch (std::exception& e) {
81284       {
81285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81286       };
81287     } catch (...) {
81288       {
81289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81290       };
81291     }
81292   }
81293 }
81294
81295
81296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
81297   void * jresult ;
81298   Dali::BaseHandle arg1 ;
81299   Dali::BaseHandle *argp1 ;
81300   Dali::Toolkit::Slider result;
81301
81302   argp1 = (Dali::BaseHandle *)jarg1;
81303   if (!argp1) {
81304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81305     return 0;
81306   }
81307   arg1 = *argp1;
81308   {
81309     try {
81310       result = Dali::Toolkit::Slider::DownCast(arg1);
81311     } catch (std::out_of_range& e) {
81312       {
81313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81314       };
81315     } catch (std::exception& e) {
81316       {
81317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81318       };
81319     } catch (...) {
81320       {
81321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81322       };
81323     }
81324   }
81325   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81326   return jresult;
81327 }
81328
81329
81330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
81331   void * jresult ;
81332   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81333   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
81334
81335   arg1 = (Dali::Toolkit::Slider *)jarg1;
81336   {
81337     try {
81338       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
81339     } catch (std::out_of_range& e) {
81340       {
81341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81342       };
81343     } catch (std::exception& e) {
81344       {
81345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81346       };
81347     } catch (...) {
81348       {
81349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81350       };
81351     }
81352   }
81353   jresult = (void *)result;
81354   return jresult;
81355 }
81356
81357
81358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
81359   void * jresult ;
81360   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81361   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
81362
81363   arg1 = (Dali::Toolkit::Slider *)jarg1;
81364   {
81365     try {
81366       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
81367     } catch (std::out_of_range& e) {
81368       {
81369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81370       };
81371     } catch (std::exception& e) {
81372       {
81373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81374       };
81375     } catch (...) {
81376       {
81377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81378       };
81379     }
81380   }
81381   jresult = (void *)result;
81382   return jresult;
81383 }
81384
81385
81386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
81387   void * jresult ;
81388   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81389   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
81390
81391   arg1 = (Dali::Toolkit::Slider *)jarg1;
81392   {
81393     try {
81394       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
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 int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
81415   int jresult ;
81416   int result;
81417
81418   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
81419   jresult = (int)result;
81420   return jresult;
81421 }
81422
81423
81424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
81425   int jresult ;
81426   int result;
81427
81428   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
81429   jresult = (int)result;
81430   return jresult;
81431 }
81432
81433
81434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
81435   int jresult ;
81436   int result;
81437
81438   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
81439   jresult = (int)result;
81440   return jresult;
81441 }
81442
81443
81444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
81445   int jresult ;
81446   int result;
81447
81448   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
81449   jresult = (int)result;
81450   return jresult;
81451 }
81452
81453
81454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
81455   void * jresult ;
81456   Dali::Toolkit::VideoView::Property *result = 0 ;
81457
81458   {
81459     try {
81460       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
81461     } catch (std::out_of_range& e) {
81462       {
81463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81464       };
81465     } catch (std::exception& e) {
81466       {
81467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81468       };
81469     } catch (...) {
81470       {
81471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81472       };
81473     }
81474   }
81475   jresult = (void *)result;
81476   return jresult;
81477 }
81478
81479
81480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
81481   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
81482
81483   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
81484   {
81485     try {
81486       delete arg1;
81487     } catch (std::out_of_range& e) {
81488       {
81489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81490       };
81491     } catch (std::exception& e) {
81492       {
81493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81494       };
81495     } catch (...) {
81496       {
81497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81498       };
81499     }
81500   }
81501 }
81502
81503
81504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
81505   void * jresult ;
81506   Dali::Toolkit::VideoView result;
81507
81508   {
81509     try {
81510       result = Dali::Toolkit::VideoView::New();
81511     } catch (std::out_of_range& e) {
81512       {
81513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81514       };
81515     } catch (std::exception& e) {
81516       {
81517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81518       };
81519     } catch (...) {
81520       {
81521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81522       };
81523     }
81524   }
81525   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81526   return jresult;
81527 }
81528
81529
81530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
81531   void * jresult ;
81532   std::string *arg1 = 0 ;
81533   Dali::Toolkit::VideoView result;
81534
81535   if (!jarg1) {
81536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81537     return 0;
81538   }
81539   std::string arg1_str(jarg1);
81540   arg1 = &arg1_str;
81541   {
81542     try {
81543       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
81544     } catch (std::out_of_range& e) {
81545       {
81546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81547       };
81548     } catch (std::exception& e) {
81549       {
81550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81551       };
81552     } catch (...) {
81553       {
81554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81555       };
81556     }
81557   }
81558   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81559
81560   //argout typemap for const std::string&
81561
81562   return jresult;
81563 }
81564
81565
81566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
81567   void * jresult ;
81568   Dali::Toolkit::VideoView *result = 0 ;
81569
81570   {
81571     try {
81572       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
81573     } catch (std::out_of_range& e) {
81574       {
81575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81576       };
81577     } catch (std::exception& e) {
81578       {
81579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81580       };
81581     } catch (...) {
81582       {
81583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81584       };
81585     }
81586   }
81587   jresult = (void *)result;
81588   return jresult;
81589 }
81590
81591
81592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
81593   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81594
81595   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81596   {
81597     try {
81598       delete arg1;
81599     } catch (std::out_of_range& e) {
81600       {
81601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81602       };
81603     } catch (std::exception& e) {
81604       {
81605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81606       };
81607     } catch (...) {
81608       {
81609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81610       };
81611     }
81612   }
81613 }
81614
81615
81616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
81617   void * jresult ;
81618   Dali::Toolkit::VideoView *arg1 = 0 ;
81619   Dali::Toolkit::VideoView *result = 0 ;
81620
81621   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81622   if (!arg1) {
81623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
81624     return 0;
81625   }
81626   {
81627     try {
81628       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
81629     } catch (std::out_of_range& e) {
81630       {
81631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81632       };
81633     } catch (std::exception& e) {
81634       {
81635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81636       };
81637     } catch (...) {
81638       {
81639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81640       };
81641     }
81642   }
81643   jresult = (void *)result;
81644   return jresult;
81645 }
81646
81647
81648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
81649   void * jresult ;
81650   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81651   Dali::Toolkit::VideoView *arg2 = 0 ;
81652   Dali::Toolkit::VideoView *result = 0 ;
81653
81654   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81655   arg2 = (Dali::Toolkit::VideoView *)jarg2;
81656   if (!arg2) {
81657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
81658     return 0;
81659   }
81660   {
81661     try {
81662       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
81663     } catch (std::out_of_range& e) {
81664       {
81665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81666       };
81667     } catch (std::exception& e) {
81668       {
81669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81670       };
81671     } catch (...) {
81672       {
81673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81674       };
81675     }
81676   }
81677   jresult = (void *)result;
81678   return jresult;
81679 }
81680
81681
81682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
81683   void * jresult ;
81684   Dali::BaseHandle arg1 ;
81685   Dali::BaseHandle *argp1 ;
81686   Dali::Toolkit::VideoView result;
81687
81688   argp1 = (Dali::BaseHandle *)jarg1;
81689   if (!argp1) {
81690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81691     return 0;
81692   }
81693   arg1 = *argp1;
81694   {
81695     try {
81696       result = Dali::Toolkit::VideoView::DownCast(arg1);
81697     } catch (std::out_of_range& e) {
81698       {
81699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81700       };
81701     } catch (std::exception& e) {
81702       {
81703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81704       };
81705     } catch (...) {
81706       {
81707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81708       };
81709     }
81710   }
81711   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81712   return jresult;
81713 }
81714
81715
81716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
81717   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81718
81719   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81720   {
81721     try {
81722       (arg1)->Play();
81723     } catch (std::out_of_range& e) {
81724       {
81725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81726       };
81727     } catch (std::exception& e) {
81728       {
81729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81730       };
81731     } catch (...) {
81732       {
81733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81734       };
81735     }
81736   }
81737 }
81738
81739
81740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
81741   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81742
81743   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81744   {
81745     try {
81746       (arg1)->Pause();
81747     } catch (std::out_of_range& e) {
81748       {
81749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81750       };
81751     } catch (std::exception& e) {
81752       {
81753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81754       };
81755     } catch (...) {
81756       {
81757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81758       };
81759     }
81760   }
81761 }
81762
81763
81764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
81765   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81766
81767   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81768   {
81769     try {
81770       (arg1)->Stop();
81771     } catch (std::out_of_range& e) {
81772       {
81773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81774       };
81775     } catch (std::exception& e) {
81776       {
81777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81778       };
81779     } catch (...) {
81780       {
81781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81782       };
81783     }
81784   }
81785 }
81786
81787
81788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
81789   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81790   int arg2 ;
81791
81792   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81793   arg2 = (int)jarg2;
81794   {
81795     try {
81796       (arg1)->Forward(arg2);
81797     } catch (std::out_of_range& e) {
81798       {
81799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81800       };
81801     } catch (std::exception& e) {
81802       {
81803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81804       };
81805     } catch (...) {
81806       {
81807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81808       };
81809     }
81810   }
81811 }
81812
81813
81814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
81815   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81816   int arg2 ;
81817
81818   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81819   arg2 = (int)jarg2;
81820   {
81821     try {
81822       (arg1)->Backward(arg2);
81823     } catch (std::out_of_range& e) {
81824       {
81825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81826       };
81827     } catch (std::exception& e) {
81828       {
81829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81830       };
81831     } catch (...) {
81832       {
81833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81834       };
81835     }
81836   }
81837 }
81838
81839
81840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
81841   void * jresult ;
81842   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81843   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
81844
81845   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81846   {
81847     try {
81848       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
81849     } catch (std::out_of_range& e) {
81850       {
81851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81852       };
81853     } catch (std::exception& e) {
81854       {
81855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81856       };
81857     } catch (...) {
81858       {
81859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81860       };
81861     }
81862   }
81863   jresult = (void *)result;
81864   return jresult;
81865 }
81866
81867
81868 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
81869   int jresult ;
81870   int result;
81871
81872   result = (int)Dali::Toolkit::Popup::Property::TITLE;
81873   jresult = (int)result;
81874   return jresult;
81875 }
81876
81877
81878 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
81879   int jresult ;
81880   int result;
81881
81882   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
81883   jresult = (int)result;
81884   return jresult;
81885 }
81886
81887
81888 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
81889   int jresult ;
81890   int result;
81891
81892   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
81893   jresult = (int)result;
81894   return jresult;
81895 }
81896
81897
81898 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
81899   int jresult ;
81900   int result;
81901
81902   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
81903   jresult = (int)result;
81904   return jresult;
81905 }
81906
81907
81908 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
81909   int jresult ;
81910   int result;
81911
81912   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
81913   jresult = (int)result;
81914   return jresult;
81915 }
81916
81917
81918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
81919   int jresult ;
81920   int result;
81921
81922   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
81923   jresult = (int)result;
81924   return jresult;
81925 }
81926
81927
81928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
81929   int jresult ;
81930   int result;
81931
81932   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
81933   jresult = (int)result;
81934   return jresult;
81935 }
81936
81937
81938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
81939   int jresult ;
81940   int result;
81941
81942   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
81943   jresult = (int)result;
81944   return jresult;
81945 }
81946
81947
81948 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
81949   int jresult ;
81950   int result;
81951
81952   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
81953   jresult = (int)result;
81954   return jresult;
81955 }
81956
81957
81958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
81959   int jresult ;
81960   int result;
81961
81962   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
81963   jresult = (int)result;
81964   return jresult;
81965 }
81966
81967
81968 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
81969   int jresult ;
81970   int result;
81971
81972   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
81973   jresult = (int)result;
81974   return jresult;
81975 }
81976
81977
81978 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
81979   int jresult ;
81980   int result;
81981
81982   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
81983   jresult = (int)result;
81984   return jresult;
81985 }
81986
81987
81988 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
81989   int jresult ;
81990   int result;
81991
81992   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
81993   jresult = (int)result;
81994   return jresult;
81995 }
81996
81997
81998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
81999   int jresult ;
82000   int result;
82001
82002   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
82003   jresult = (int)result;
82004   return jresult;
82005 }
82006
82007
82008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
82009   int jresult ;
82010   int result;
82011
82012   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
82013   jresult = (int)result;
82014   return jresult;
82015 }
82016
82017
82018 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
82019   int jresult ;
82020   int result;
82021
82022   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
82023   jresult = (int)result;
82024   return jresult;
82025 }
82026
82027
82028 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
82029   int jresult ;
82030   int result;
82031
82032   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
82033   jresult = (int)result;
82034   return jresult;
82035 }
82036
82037
82038 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
82039   int jresult ;
82040   int result;
82041
82042   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
82043   jresult = (int)result;
82044   return jresult;
82045 }
82046
82047
82048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
82049   int jresult ;
82050   int result;
82051
82052   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
82053   jresult = (int)result;
82054   return jresult;
82055 }
82056
82057
82058 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
82059   int jresult ;
82060   int result;
82061
82062   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
82063   jresult = (int)result;
82064   return jresult;
82065 }
82066
82067
82068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
82069   int jresult ;
82070   int result;
82071
82072   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
82073   jresult = (int)result;
82074   return jresult;
82075 }
82076
82077
82078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
82079   void * jresult ;
82080   Dali::Toolkit::Popup::Property *result = 0 ;
82081
82082   {
82083     try {
82084       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
82085     } catch (std::out_of_range& e) {
82086       {
82087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82088       };
82089     } catch (std::exception& e) {
82090       {
82091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82092       };
82093     } catch (...) {
82094       {
82095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82096       };
82097     }
82098   }
82099   jresult = (void *)result;
82100   return jresult;
82101 }
82102
82103
82104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
82105   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
82106
82107   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
82108   {
82109     try {
82110       delete arg1;
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_new_Popup__SWIG_0() {
82129   void * jresult ;
82130   Dali::Toolkit::Popup *result = 0 ;
82131
82132   {
82133     try {
82134       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
82135     } catch (std::out_of_range& e) {
82136       {
82137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82138       };
82139     } catch (std::exception& e) {
82140       {
82141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82142       };
82143     } catch (...) {
82144       {
82145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82146       };
82147     }
82148   }
82149   jresult = (void *)result;
82150   return jresult;
82151 }
82152
82153
82154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
82155   void * jresult ;
82156   Dali::Toolkit::Popup result;
82157
82158   {
82159     try {
82160       result = Dali::Toolkit::Popup::New();
82161     } catch (std::out_of_range& e) {
82162       {
82163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82164       };
82165     } catch (std::exception& e) {
82166       {
82167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82168       };
82169     } catch (...) {
82170       {
82171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82172       };
82173     }
82174   }
82175   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
82176   return jresult;
82177 }
82178
82179
82180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
82181   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82182
82183   arg1 = (Dali::Toolkit::Popup *)jarg1;
82184   {
82185     try {
82186       delete arg1;
82187     } catch (std::out_of_range& e) {
82188       {
82189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82190       };
82191     } catch (std::exception& e) {
82192       {
82193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82194       };
82195     } catch (...) {
82196       {
82197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82198       };
82199     }
82200   }
82201 }
82202
82203
82204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
82205   void * jresult ;
82206   Dali::Toolkit::Popup *arg1 = 0 ;
82207   Dali::Toolkit::Popup *result = 0 ;
82208
82209   arg1 = (Dali::Toolkit::Popup *)jarg1;
82210   if (!arg1) {
82211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
82212     return 0;
82213   }
82214   {
82215     try {
82216       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
82217     } catch (std::out_of_range& e) {
82218       {
82219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82220       };
82221     } catch (std::exception& e) {
82222       {
82223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82224       };
82225     } catch (...) {
82226       {
82227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82228       };
82229     }
82230   }
82231   jresult = (void *)result;
82232   return jresult;
82233 }
82234
82235
82236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
82237   void * jresult ;
82238   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82239   Dali::Toolkit::Popup *arg2 = 0 ;
82240   Dali::Toolkit::Popup *result = 0 ;
82241
82242   arg1 = (Dali::Toolkit::Popup *)jarg1;
82243   arg2 = (Dali::Toolkit::Popup *)jarg2;
82244   if (!arg2) {
82245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
82246     return 0;
82247   }
82248   {
82249     try {
82250       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
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 = (void *)result;
82266   return jresult;
82267 }
82268
82269
82270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
82271   void * jresult ;
82272   Dali::BaseHandle arg1 ;
82273   Dali::BaseHandle *argp1 ;
82274   Dali::Toolkit::Popup result;
82275
82276   argp1 = (Dali::BaseHandle *)jarg1;
82277   if (!argp1) {
82278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82279     return 0;
82280   }
82281   arg1 = *argp1;
82282   {
82283     try {
82284       result = Dali::Toolkit::Popup::DownCast(arg1);
82285     } catch (std::out_of_range& e) {
82286       {
82287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82288       };
82289     } catch (std::exception& e) {
82290       {
82291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82292       };
82293     } catch (...) {
82294       {
82295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82296       };
82297     }
82298   }
82299   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
82300   return jresult;
82301 }
82302
82303
82304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
82305   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82306   Dali::Actor arg2 ;
82307   Dali::Actor *argp2 ;
82308
82309   arg1 = (Dali::Toolkit::Popup *)jarg1;
82310   argp2 = (Dali::Actor *)jarg2;
82311   if (!argp2) {
82312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82313     return ;
82314   }
82315   arg2 = *argp2;
82316   {
82317     try {
82318       (arg1)->SetTitle(arg2);
82319     } catch (std::out_of_range& e) {
82320       {
82321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82322       };
82323     } catch (std::exception& e) {
82324       {
82325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82326       };
82327     } catch (...) {
82328       {
82329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82330       };
82331     }
82332   }
82333 }
82334
82335
82336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
82337   void * jresult ;
82338   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82339   Dali::Actor result;
82340
82341   arg1 = (Dali::Toolkit::Popup *)jarg1;
82342   {
82343     try {
82344       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
82345     } catch (std::out_of_range& e) {
82346       {
82347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82348       };
82349     } catch (std::exception& e) {
82350       {
82351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82352       };
82353     } catch (...) {
82354       {
82355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82356       };
82357     }
82358   }
82359   jresult = new Dali::Actor((const Dali::Actor &)result);
82360   return jresult;
82361 }
82362
82363
82364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
82365   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82366   Dali::Actor arg2 ;
82367   Dali::Actor *argp2 ;
82368
82369   arg1 = (Dali::Toolkit::Popup *)jarg1;
82370   argp2 = (Dali::Actor *)jarg2;
82371   if (!argp2) {
82372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82373     return ;
82374   }
82375   arg2 = *argp2;
82376   {
82377     try {
82378       (arg1)->SetContent(arg2);
82379     } catch (std::out_of_range& e) {
82380       {
82381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82382       };
82383     } catch (std::exception& e) {
82384       {
82385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82386       };
82387     } catch (...) {
82388       {
82389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82390       };
82391     }
82392   }
82393 }
82394
82395
82396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
82397   void * jresult ;
82398   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82399   Dali::Actor result;
82400
82401   arg1 = (Dali::Toolkit::Popup *)jarg1;
82402   {
82403     try {
82404       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
82405     } catch (std::out_of_range& e) {
82406       {
82407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82408       };
82409     } catch (std::exception& e) {
82410       {
82411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82412       };
82413     } catch (...) {
82414       {
82415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82416       };
82417     }
82418   }
82419   jresult = new Dali::Actor((const Dali::Actor &)result);
82420   return jresult;
82421 }
82422
82423
82424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
82425   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82426   Dali::Actor arg2 ;
82427   Dali::Actor *argp2 ;
82428
82429   arg1 = (Dali::Toolkit::Popup *)jarg1;
82430   argp2 = (Dali::Actor *)jarg2;
82431   if (!argp2) {
82432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82433     return ;
82434   }
82435   arg2 = *argp2;
82436   {
82437     try {
82438       (arg1)->SetFooter(arg2);
82439     } catch (std::out_of_range& e) {
82440       {
82441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82442       };
82443     } catch (std::exception& e) {
82444       {
82445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82446       };
82447     } catch (...) {
82448       {
82449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82450       };
82451     }
82452   }
82453 }
82454
82455
82456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
82457   void * jresult ;
82458   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82459   Dali::Actor result;
82460
82461   arg1 = (Dali::Toolkit::Popup *)jarg1;
82462   {
82463     try {
82464       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
82465     } catch (std::out_of_range& e) {
82466       {
82467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82468       };
82469     } catch (std::exception& e) {
82470       {
82471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82472       };
82473     } catch (...) {
82474       {
82475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82476       };
82477     }
82478   }
82479   jresult = new Dali::Actor((const Dali::Actor &)result);
82480   return jresult;
82481 }
82482
82483
82484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
82485   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82486   Dali::Toolkit::Popup::DisplayState arg2 ;
82487
82488   arg1 = (Dali::Toolkit::Popup *)jarg1;
82489   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
82490   {
82491     try {
82492       (arg1)->SetDisplayState(arg2);
82493     } catch (std::out_of_range& e) {
82494       {
82495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82496       };
82497     } catch (std::exception& e) {
82498       {
82499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82500       };
82501     } catch (...) {
82502       {
82503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82504       };
82505     }
82506   }
82507 }
82508
82509
82510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
82511   int jresult ;
82512   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82513   Dali::Toolkit::Popup::DisplayState result;
82514
82515   arg1 = (Dali::Toolkit::Popup *)jarg1;
82516   {
82517     try {
82518       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
82519     } catch (std::out_of_range& e) {
82520       {
82521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82522       };
82523     } catch (std::exception& e) {
82524       {
82525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82526       };
82527     } catch (...) {
82528       {
82529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82530       };
82531     }
82532   }
82533   jresult = (int)result;
82534   return jresult;
82535 }
82536
82537
82538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
82539   void * jresult ;
82540   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82541   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
82542
82543   arg1 = (Dali::Toolkit::Popup *)jarg1;
82544   {
82545     try {
82546       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
82547     } catch (std::out_of_range& e) {
82548       {
82549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82550       };
82551     } catch (std::exception& e) {
82552       {
82553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82554       };
82555     } catch (...) {
82556       {
82557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82558       };
82559     }
82560   }
82561   jresult = (void *)result;
82562   return jresult;
82563 }
82564
82565
82566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
82567   void * jresult ;
82568   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82569   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
82570
82571   arg1 = (Dali::Toolkit::Popup *)jarg1;
82572   {
82573     try {
82574       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
82575     } catch (std::out_of_range& e) {
82576       {
82577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82578       };
82579     } catch (std::exception& e) {
82580       {
82581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82582       };
82583     } catch (...) {
82584       {
82585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82586       };
82587     }
82588   }
82589   jresult = (void *)result;
82590   return jresult;
82591 }
82592
82593
82594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
82595   void * jresult ;
82596   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82597   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
82598
82599   arg1 = (Dali::Toolkit::Popup *)jarg1;
82600   {
82601     try {
82602       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
82603     } catch (std::out_of_range& e) {
82604       {
82605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82606       };
82607     } catch (std::exception& e) {
82608       {
82609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82610       };
82611     } catch (...) {
82612       {
82613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82614       };
82615     }
82616   }
82617   jresult = (void *)result;
82618   return jresult;
82619 }
82620
82621
82622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
82623   void * jresult ;
82624   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82625   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
82626
82627   arg1 = (Dali::Toolkit::Popup *)jarg1;
82628   {
82629     try {
82630       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
82631     } catch (std::out_of_range& e) {
82632       {
82633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82634       };
82635     } catch (std::exception& e) {
82636       {
82637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82638       };
82639     } catch (...) {
82640       {
82641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82642       };
82643     }
82644   }
82645   jresult = (void *)result;
82646   return jresult;
82647 }
82648
82649
82650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
82651   void * jresult ;
82652   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82653   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
82654
82655   arg1 = (Dali::Toolkit::Popup *)jarg1;
82656   {
82657     try {
82658       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
82659     } catch (std::out_of_range& e) {
82660       {
82661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82662       };
82663     } catch (std::exception& e) {
82664       {
82665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82666       };
82667     } catch (...) {
82668       {
82669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82670       };
82671     }
82672   }
82673   jresult = (void *)result;
82674   return jresult;
82675 }
82676
82677
82678 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
82679   int jresult ;
82680   int result;
82681
82682   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
82683   jresult = (int)result;
82684   return jresult;
82685 }
82686
82687
82688 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
82689   int jresult ;
82690   int result;
82691
82692   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
82693   jresult = (int)result;
82694   return jresult;
82695 }
82696
82697
82698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
82699   int jresult ;
82700   int result;
82701
82702   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
82703   jresult = (int)result;
82704   return jresult;
82705 }
82706
82707
82708 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
82709   int jresult ;
82710   int result;
82711
82712   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
82713   jresult = (int)result;
82714   return jresult;
82715 }
82716
82717
82718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
82719   int jresult ;
82720   int result;
82721
82722   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
82723   jresult = (int)result;
82724   return jresult;
82725 }
82726
82727
82728 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
82729   int jresult ;
82730   int result;
82731
82732   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
82733   jresult = (int)result;
82734   return jresult;
82735 }
82736
82737
82738 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
82739   int jresult ;
82740   int result;
82741
82742   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
82743   jresult = (int)result;
82744   return jresult;
82745 }
82746
82747
82748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
82749   int jresult ;
82750   int result;
82751
82752   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
82753   jresult = (int)result;
82754   return jresult;
82755 }
82756
82757
82758 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
82759   int jresult ;
82760   int result;
82761
82762   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
82763   jresult = (int)result;
82764   return jresult;
82765 }
82766
82767
82768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
82769   void * jresult ;
82770   Dali::Toolkit::ProgressBar::Property *result = 0 ;
82771
82772   {
82773     try {
82774       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
82775     } catch (std::out_of_range& e) {
82776       {
82777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82778       };
82779     } catch (std::exception& e) {
82780       {
82781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82782       };
82783     } catch (...) {
82784       {
82785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82786       };
82787     }
82788   }
82789   jresult = (void *)result;
82790   return jresult;
82791 }
82792
82793
82794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
82795   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
82796
82797   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
82798   {
82799     try {
82800       delete arg1;
82801     } catch (std::out_of_range& e) {
82802       {
82803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82804       };
82805     } catch (std::exception& e) {
82806       {
82807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82808       };
82809     } catch (...) {
82810       {
82811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82812       };
82813     }
82814   }
82815 }
82816
82817
82818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
82819   void * jresult ;
82820   Dali::Toolkit::ProgressBar result;
82821
82822   {
82823     try {
82824       result = Dali::Toolkit::ProgressBar::New();
82825     } catch (std::out_of_range& e) {
82826       {
82827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82828       };
82829     } catch (std::exception& e) {
82830       {
82831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82832       };
82833     } catch (...) {
82834       {
82835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82836       };
82837     }
82838   }
82839   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
82840   return jresult;
82841 }
82842
82843
82844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
82845   void * jresult ;
82846   Dali::Toolkit::ProgressBar *result = 0 ;
82847
82848   {
82849     try {
82850       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
82851     } catch (std::out_of_range& e) {
82852       {
82853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82854       };
82855     } catch (std::exception& e) {
82856       {
82857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82858       };
82859     } catch (...) {
82860       {
82861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82862       };
82863     }
82864   }
82865   jresult = (void *)result;
82866   return jresult;
82867 }
82868
82869
82870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
82871   void * jresult ;
82872   Dali::Toolkit::ProgressBar *arg1 = 0 ;
82873   Dali::Toolkit::ProgressBar *result = 0 ;
82874
82875   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82876   if (!arg1) {
82877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
82878     return 0;
82879   }
82880   {
82881     try {
82882       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
82883     } catch (std::out_of_range& e) {
82884       {
82885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82886       };
82887     } catch (std::exception& e) {
82888       {
82889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82890       };
82891     } catch (...) {
82892       {
82893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82894       };
82895     }
82896   }
82897   jresult = (void *)result;
82898   return jresult;
82899 }
82900
82901
82902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
82903   void * jresult ;
82904   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
82905   Dali::Toolkit::ProgressBar *arg2 = 0 ;
82906   Dali::Toolkit::ProgressBar *result = 0 ;
82907
82908   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82909   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
82910   if (!arg2) {
82911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
82912     return 0;
82913   }
82914   {
82915     try {
82916       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
82917     } catch (std::out_of_range& e) {
82918       {
82919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82920       };
82921     } catch (std::exception& e) {
82922       {
82923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82924       };
82925     } catch (...) {
82926       {
82927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82928       };
82929     }
82930   }
82931   jresult = (void *)result;
82932   return jresult;
82933 }
82934
82935
82936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
82937   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
82938
82939   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82940   {
82941     try {
82942       delete arg1;
82943     } catch (std::out_of_range& e) {
82944       {
82945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82946       };
82947     } catch (std::exception& e) {
82948       {
82949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82950       };
82951     } catch (...) {
82952       {
82953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82954       };
82955     }
82956   }
82957 }
82958
82959
82960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
82961   void * jresult ;
82962   Dali::BaseHandle arg1 ;
82963   Dali::BaseHandle *argp1 ;
82964   Dali::Toolkit::ProgressBar result;
82965
82966   argp1 = (Dali::BaseHandle *)jarg1;
82967   if (!argp1) {
82968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82969     return 0;
82970   }
82971   arg1 = *argp1;
82972   {
82973     try {
82974       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
82975     } catch (std::out_of_range& e) {
82976       {
82977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82978       };
82979     } catch (std::exception& e) {
82980       {
82981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82982       };
82983     } catch (...) {
82984       {
82985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82986       };
82987     }
82988   }
82989   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
82990   return jresult;
82991 }
82992
82993
82994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
82995   void * jresult ;
82996   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
82997   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
82998
82999   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83000   {
83001     try {
83002       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
83003     } catch (std::out_of_range& e) {
83004       {
83005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83006       };
83007     } catch (std::exception& e) {
83008       {
83009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83010       };
83011     } catch (...) {
83012       {
83013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83014       };
83015     }
83016   }
83017   jresult = (void *)result;
83018   return jresult;
83019 }
83020
83021
83022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
83023   void * jresult ;
83024   Dali::Toolkit::GaussianBlurView *result = 0 ;
83025
83026   {
83027     try {
83028       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
83029     } catch (std::out_of_range& e) {
83030       {
83031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83032       };
83033     } catch (std::exception& e) {
83034       {
83035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83036       };
83037     } catch (...) {
83038       {
83039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83040       };
83041     }
83042   }
83043   jresult = (void *)result;
83044   return jresult;
83045 }
83046
83047
83048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
83049   void * jresult ;
83050   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
83051   Dali::Toolkit::GaussianBlurView *result = 0 ;
83052
83053   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83054   if (!arg1) {
83055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83056     return 0;
83057   }
83058   {
83059     try {
83060       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
83061     } catch (std::out_of_range& e) {
83062       {
83063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83064       };
83065     } catch (std::exception& e) {
83066       {
83067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83068       };
83069     } catch (...) {
83070       {
83071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83072       };
83073     }
83074   }
83075   jresult = (void *)result;
83076   return jresult;
83077 }
83078
83079
83080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
83081   void * jresult ;
83082   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83083   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
83084   Dali::Toolkit::GaussianBlurView *result = 0 ;
83085
83086   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83087   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
83088   if (!arg2) {
83089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83090     return 0;
83091   }
83092   {
83093     try {
83094       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
83095     } catch (std::out_of_range& e) {
83096       {
83097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83098       };
83099     } catch (std::exception& e) {
83100       {
83101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83102       };
83103     } catch (...) {
83104       {
83105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83106       };
83107     }
83108   }
83109   jresult = (void *)result;
83110   return jresult;
83111 }
83112
83113
83114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
83115   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83116
83117   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83118   {
83119     try {
83120       delete arg1;
83121     } catch (std::out_of_range& e) {
83122       {
83123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83124       };
83125     } catch (std::exception& e) {
83126       {
83127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83128       };
83129     } catch (...) {
83130       {
83131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83132       };
83133     }
83134   }
83135 }
83136
83137
83138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
83139   void * jresult ;
83140   Dali::BaseHandle arg1 ;
83141   Dali::BaseHandle *argp1 ;
83142   Dali::Toolkit::GaussianBlurView result;
83143
83144   argp1 = (Dali::BaseHandle *)jarg1;
83145   if (!argp1) {
83146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83147     return 0;
83148   }
83149   arg1 = *argp1;
83150   {
83151     try {
83152       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
83153     } catch (std::out_of_range& e) {
83154       {
83155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83156       };
83157     } catch (std::exception& e) {
83158       {
83159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83160       };
83161     } catch (...) {
83162       {
83163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83164       };
83165     }
83166   }
83167   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83168   return jresult;
83169 }
83170
83171
83172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
83173   void * jresult ;
83174   Dali::Toolkit::GaussianBlurView result;
83175
83176   {
83177     try {
83178       result = Dali::Toolkit::GaussianBlurView::New();
83179     } catch (std::out_of_range& e) {
83180       {
83181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83182       };
83183     } catch (std::exception& e) {
83184       {
83185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83186       };
83187     } catch (...) {
83188       {
83189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83190       };
83191     }
83192   }
83193   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83194   return jresult;
83195 }
83196
83197
83198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
83199   void * jresult ;
83200   unsigned int arg1 ;
83201   float arg2 ;
83202   Dali::Pixel::Format arg3 ;
83203   float arg4 ;
83204   float arg5 ;
83205   bool arg6 ;
83206   Dali::Toolkit::GaussianBlurView result;
83207
83208   arg1 = (unsigned int)jarg1;
83209   arg2 = (float)jarg2;
83210   arg3 = (Dali::Pixel::Format)jarg3;
83211   arg4 = (float)jarg4;
83212   arg5 = (float)jarg5;
83213   arg6 = jarg6 ? true : false;
83214   {
83215     try {
83216       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
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::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83232   return jresult;
83233 }
83234
83235
83236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
83237   void * jresult ;
83238   unsigned int arg1 ;
83239   float arg2 ;
83240   Dali::Pixel::Format arg3 ;
83241   float arg4 ;
83242   float arg5 ;
83243   Dali::Toolkit::GaussianBlurView result;
83244
83245   arg1 = (unsigned int)jarg1;
83246   arg2 = (float)jarg2;
83247   arg3 = (Dali::Pixel::Format)jarg3;
83248   arg4 = (float)jarg4;
83249   arg5 = (float)jarg5;
83250   {
83251     try {
83252       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
83253     } catch (std::out_of_range& e) {
83254       {
83255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83256       };
83257     } catch (std::exception& e) {
83258       {
83259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83260       };
83261     } catch (...) {
83262       {
83263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83264       };
83265     }
83266   }
83267   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83268   return jresult;
83269 }
83270
83271
83272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
83273   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83274   Dali::Actor arg2 ;
83275   Dali::Actor *argp2 ;
83276
83277   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83278   argp2 = (Dali::Actor *)jarg2;
83279   if (!argp2) {
83280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83281     return ;
83282   }
83283   arg2 = *argp2;
83284   {
83285     try {
83286       (arg1)->Add(arg2);
83287     } catch (std::out_of_range& e) {
83288       {
83289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83290       };
83291     } catch (std::exception& e) {
83292       {
83293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83294       };
83295     } catch (...) {
83296       {
83297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83298       };
83299     }
83300   }
83301 }
83302
83303
83304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
83305   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83306   Dali::Actor arg2 ;
83307   Dali::Actor *argp2 ;
83308
83309   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83310   argp2 = (Dali::Actor *)jarg2;
83311   if (!argp2) {
83312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83313     return ;
83314   }
83315   arg2 = *argp2;
83316   {
83317     try {
83318       (arg1)->Remove(arg2);
83319     } catch (std::out_of_range& e) {
83320       {
83321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83322       };
83323     } catch (std::exception& e) {
83324       {
83325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83326       };
83327     } catch (...) {
83328       {
83329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83330       };
83331     }
83332   }
83333 }
83334
83335
83336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
83337   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83338
83339   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83340   {
83341     try {
83342       (arg1)->Activate();
83343     } catch (std::out_of_range& e) {
83344       {
83345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83346       };
83347     } catch (std::exception& e) {
83348       {
83349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83350       };
83351     } catch (...) {
83352       {
83353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83354       };
83355     }
83356   }
83357 }
83358
83359
83360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
83361   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83362
83363   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83364   {
83365     try {
83366       (arg1)->ActivateOnce();
83367     } catch (std::out_of_range& e) {
83368       {
83369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83370       };
83371     } catch (std::exception& e) {
83372       {
83373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83374       };
83375     } catch (...) {
83376       {
83377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83378       };
83379     }
83380   }
83381 }
83382
83383
83384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
83385   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83386
83387   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83388   {
83389     try {
83390       (arg1)->Deactivate();
83391     } catch (std::out_of_range& e) {
83392       {
83393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83394       };
83395     } catch (std::exception& e) {
83396       {
83397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83398       };
83399     } catch (...) {
83400       {
83401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83402       };
83403     }
83404   }
83405 }
83406
83407
83408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
83409   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83410   Dali::Image arg2 ;
83411   Dali::FrameBufferImage arg3 ;
83412   Dali::Image *argp2 ;
83413   Dali::FrameBufferImage *argp3 ;
83414
83415   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83416   argp2 = (Dali::Image *)jarg2;
83417   if (!argp2) {
83418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
83419     return ;
83420   }
83421   arg2 = *argp2;
83422   argp3 = (Dali::FrameBufferImage *)jarg3;
83423   if (!argp3) {
83424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
83425     return ;
83426   }
83427   arg3 = *argp3;
83428   {
83429     try {
83430       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
83431     } catch (std::out_of_range& e) {
83432       {
83433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83434       };
83435     } catch (std::exception& e) {
83436       {
83437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83438       };
83439     } catch (...) {
83440       {
83441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83442       };
83443     }
83444   }
83445 }
83446
83447
83448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
83449   int jresult ;
83450   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83451   Dali::Property::Index result;
83452
83453   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83454   {
83455     try {
83456       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
83457     } catch (std::out_of_range& e) {
83458       {
83459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83460       };
83461     } catch (std::exception& e) {
83462       {
83463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83464       };
83465     } catch (...) {
83466       {
83467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83468       };
83469     }
83470   }
83471   jresult = result;
83472   return jresult;
83473 }
83474
83475
83476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
83477   void * jresult ;
83478   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83479   Dali::FrameBufferImage result;
83480
83481   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83482   {
83483     try {
83484       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
83485     } catch (std::out_of_range& e) {
83486       {
83487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83488       };
83489     } catch (std::exception& e) {
83490       {
83491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83492       };
83493     } catch (...) {
83494       {
83495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83496       };
83497     }
83498   }
83499   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
83500   return jresult;
83501 }
83502
83503
83504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
83505   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83506   Dali::Vector4 *arg2 = 0 ;
83507
83508   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83509   arg2 = (Dali::Vector4 *)jarg2;
83510   if (!arg2) {
83511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
83512     return ;
83513   }
83514   {
83515     try {
83516       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
83517     } catch (std::out_of_range& e) {
83518       {
83519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83520       };
83521     } catch (std::exception& e) {
83522       {
83523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83524       };
83525     } catch (...) {
83526       {
83527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83528       };
83529     }
83530   }
83531 }
83532
83533
83534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
83535   void * jresult ;
83536   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83537   Dali::Vector4 result;
83538
83539   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83540   {
83541     try {
83542       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
83543     } catch (std::out_of_range& e) {
83544       {
83545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83546       };
83547     } catch (std::exception& e) {
83548       {
83549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83550       };
83551     } catch (...) {
83552       {
83553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83554       };
83555     }
83556   }
83557   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
83558   return jresult;
83559 }
83560
83561
83562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
83563   void * jresult ;
83564   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83565   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
83566
83567   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83568   {
83569     try {
83570       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
83571     } catch (std::out_of_range& e) {
83572       {
83573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83574       };
83575     } catch (std::exception& e) {
83576       {
83577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83578       };
83579     } catch (...) {
83580       {
83581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83582       };
83583     }
83584   }
83585   jresult = (void *)result;
83586   return jresult;
83587 }
83588
83589
83590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
83591   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
83592
83593   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83594   {
83595     try {
83596       delete arg1;
83597     } catch (std::out_of_range& e) {
83598       {
83599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83600       };
83601     } catch (std::exception& e) {
83602       {
83603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83604       };
83605     } catch (...) {
83606       {
83607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83608       };
83609     }
83610   }
83611 }
83612
83613
83614 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
83615   unsigned int jresult ;
83616   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
83617   unsigned int result;
83618
83619   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83620   {
83621     try {
83622       result = (unsigned int)(arg1)->GetNumberOfPages();
83623     } catch (std::out_of_range& e) {
83624       {
83625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83626       };
83627     } catch (std::exception& e) {
83628       {
83629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83630       };
83631     } catch (...) {
83632       {
83633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83634       };
83635     }
83636   }
83637   jresult = result;
83638   return jresult;
83639 }
83640
83641
83642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
83643   void * jresult ;
83644   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
83645   unsigned int arg2 ;
83646   Dali::Texture result;
83647
83648   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83649   arg2 = (unsigned int)jarg2;
83650   {
83651     try {
83652       result = (arg1)->NewPage(arg2);
83653     } catch (std::out_of_range& e) {
83654       {
83655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83656       };
83657     } catch (std::exception& e) {
83658       {
83659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83660       };
83661     } catch (...) {
83662       {
83663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83664       };
83665     }
83666   }
83667   jresult = new Dali::Texture((const Dali::Texture &)result);
83668   return jresult;
83669 }
83670
83671
83672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
83673   int jresult ;
83674   int result;
83675
83676   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
83677   jresult = (int)result;
83678   return jresult;
83679 }
83680
83681
83682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
83683   int jresult ;
83684   int result;
83685
83686   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
83687   jresult = (int)result;
83688   return jresult;
83689 }
83690
83691
83692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
83693   int jresult ;
83694   int result;
83695
83696   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
83697   jresult = (int)result;
83698   return jresult;
83699 }
83700
83701
83702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
83703   void * jresult ;
83704   Dali::Toolkit::PageTurnView::Property *result = 0 ;
83705
83706   {
83707     try {
83708       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
83709     } catch (std::out_of_range& e) {
83710       {
83711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83712       };
83713     } catch (std::exception& e) {
83714       {
83715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83716       };
83717     } catch (...) {
83718       {
83719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83720       };
83721     }
83722   }
83723   jresult = (void *)result;
83724   return jresult;
83725 }
83726
83727
83728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
83729   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
83730
83731   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
83732   {
83733     try {
83734       delete arg1;
83735     } catch (std::out_of_range& e) {
83736       {
83737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83738       };
83739     } catch (std::exception& e) {
83740       {
83741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83742       };
83743     } catch (...) {
83744       {
83745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83746       };
83747     }
83748   }
83749 }
83750
83751
83752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
83753   void * jresult ;
83754   Dali::Toolkit::PageTurnView *result = 0 ;
83755
83756   {
83757     try {
83758       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
83759     } catch (std::out_of_range& e) {
83760       {
83761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83762       };
83763     } catch (std::exception& e) {
83764       {
83765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83766       };
83767     } catch (...) {
83768       {
83769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83770       };
83771     }
83772   }
83773   jresult = (void *)result;
83774   return jresult;
83775 }
83776
83777
83778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
83779   void * jresult ;
83780   Dali::Toolkit::PageTurnView *arg1 = 0 ;
83781   Dali::Toolkit::PageTurnView *result = 0 ;
83782
83783   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83784   if (!arg1) {
83785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
83786     return 0;
83787   }
83788   {
83789     try {
83790       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
83791     } catch (std::out_of_range& e) {
83792       {
83793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83794       };
83795     } catch (std::exception& e) {
83796       {
83797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83798       };
83799     } catch (...) {
83800       {
83801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83802       };
83803     }
83804   }
83805   jresult = (void *)result;
83806   return jresult;
83807 }
83808
83809
83810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
83811   void * jresult ;
83812   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83813   Dali::Toolkit::PageTurnView *arg2 = 0 ;
83814   Dali::Toolkit::PageTurnView *result = 0 ;
83815
83816   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83817   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
83818   if (!arg2) {
83819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
83820     return 0;
83821   }
83822   {
83823     try {
83824       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
83825     } catch (std::out_of_range& e) {
83826       {
83827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83828       };
83829     } catch (std::exception& e) {
83830       {
83831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83832       };
83833     } catch (...) {
83834       {
83835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83836       };
83837     }
83838   }
83839   jresult = (void *)result;
83840   return jresult;
83841 }
83842
83843
83844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
83845   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83846
83847   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83848   {
83849     try {
83850       delete arg1;
83851     } catch (std::out_of_range& e) {
83852       {
83853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83854       };
83855     } catch (std::exception& e) {
83856       {
83857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83858       };
83859     } catch (...) {
83860       {
83861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83862       };
83863     }
83864   }
83865 }
83866
83867
83868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
83869   void * jresult ;
83870   Dali::BaseHandle arg1 ;
83871   Dali::BaseHandle *argp1 ;
83872   Dali::Toolkit::PageTurnView result;
83873
83874   argp1 = (Dali::BaseHandle *)jarg1;
83875   if (!argp1) {
83876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83877     return 0;
83878   }
83879   arg1 = *argp1;
83880   {
83881     try {
83882       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
83883     } catch (std::out_of_range& e) {
83884       {
83885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83886       };
83887     } catch (std::exception& e) {
83888       {
83889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83890       };
83891     } catch (...) {
83892       {
83893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83894       };
83895     }
83896   }
83897   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
83898   return jresult;
83899 }
83900
83901
83902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
83903   void * jresult ;
83904   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83905   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
83906
83907   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83908   {
83909     try {
83910       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
83911     } catch (std::out_of_range& e) {
83912       {
83913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83914       };
83915     } catch (std::exception& e) {
83916       {
83917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83918       };
83919     } catch (...) {
83920       {
83921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83922       };
83923     }
83924   }
83925   jresult = (void *)result;
83926   return jresult;
83927 }
83928
83929
83930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
83931   void * jresult ;
83932   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83933   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
83934
83935   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83936   {
83937     try {
83938       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
83939     } catch (std::out_of_range& e) {
83940       {
83941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83942       };
83943     } catch (std::exception& e) {
83944       {
83945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83946       };
83947     } catch (...) {
83948       {
83949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83950       };
83951     }
83952   }
83953   jresult = (void *)result;
83954   return jresult;
83955 }
83956
83957
83958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
83959   void * jresult ;
83960   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83961   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
83962
83963   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83964   {
83965     try {
83966       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
83967     } catch (std::out_of_range& e) {
83968       {
83969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83970       };
83971     } catch (std::exception& e) {
83972       {
83973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83974       };
83975     } catch (...) {
83976       {
83977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83978       };
83979     }
83980   }
83981   jresult = (void *)result;
83982   return jresult;
83983 }
83984
83985
83986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
83987   void * jresult ;
83988   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83989   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
83990
83991   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83992   {
83993     try {
83994       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
83995     } catch (std::out_of_range& e) {
83996       {
83997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83998       };
83999     } catch (std::exception& e) {
84000       {
84001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84002       };
84003     } catch (...) {
84004       {
84005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84006       };
84007     }
84008   }
84009   jresult = (void *)result;
84010   return jresult;
84011 }
84012
84013
84014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
84015   void * jresult ;
84016   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84017
84018   {
84019     try {
84020       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
84021     } catch (std::out_of_range& e) {
84022       {
84023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84024       };
84025     } catch (std::exception& e) {
84026       {
84027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84028       };
84029     } catch (...) {
84030       {
84031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84032       };
84033     }
84034   }
84035   jresult = (void *)result;
84036   return jresult;
84037 }
84038
84039
84040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
84041   void * jresult ;
84042   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
84043   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84044
84045   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84046   if (!arg1) {
84047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
84048     return 0;
84049   }
84050   {
84051     try {
84052       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
84053     } catch (std::out_of_range& e) {
84054       {
84055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84056       };
84057     } catch (std::exception& e) {
84058       {
84059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84060       };
84061     } catch (...) {
84062       {
84063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84064       };
84065     }
84066   }
84067   jresult = (void *)result;
84068   return jresult;
84069 }
84070
84071
84072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
84073   void * jresult ;
84074   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
84075   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
84076   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84077
84078   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84079   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
84080   if (!arg2) {
84081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
84082     return 0;
84083   }
84084   {
84085     try {
84086       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
84087     } catch (std::out_of_range& e) {
84088       {
84089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84090       };
84091     } catch (std::exception& e) {
84092       {
84093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84094       };
84095     } catch (...) {
84096       {
84097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84098       };
84099     }
84100   }
84101   jresult = (void *)result;
84102   return jresult;
84103 }
84104
84105
84106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
84107   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
84108
84109   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84110   {
84111     try {
84112       delete arg1;
84113     } catch (std::out_of_range& e) {
84114       {
84115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84116       };
84117     } catch (std::exception& e) {
84118       {
84119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84120       };
84121     } catch (...) {
84122       {
84123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84124       };
84125     }
84126   }
84127 }
84128
84129
84130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
84131   void * jresult ;
84132   Dali::Toolkit::PageFactory *arg1 = 0 ;
84133   Dali::Vector2 *arg2 = 0 ;
84134   Dali::Toolkit::PageTurnLandscapeView result;
84135
84136   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84137   if (!arg1) {
84138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
84139     return 0;
84140   }
84141   arg2 = (Dali::Vector2 *)jarg2;
84142   if (!arg2) {
84143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
84144     return 0;
84145   }
84146   {
84147     try {
84148       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
84149     } catch (std::out_of_range& e) {
84150       {
84151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84152       };
84153     } catch (std::exception& e) {
84154       {
84155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84156       };
84157     } catch (...) {
84158       {
84159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84160       };
84161     }
84162   }
84163   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
84164   return jresult;
84165 }
84166
84167
84168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
84169   void * jresult ;
84170   Dali::BaseHandle arg1 ;
84171   Dali::BaseHandle *argp1 ;
84172   Dali::Toolkit::PageTurnLandscapeView result;
84173
84174   argp1 = (Dali::BaseHandle *)jarg1;
84175   if (!argp1) {
84176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84177     return 0;
84178   }
84179   arg1 = *argp1;
84180   {
84181     try {
84182       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
84183     } catch (std::out_of_range& e) {
84184       {
84185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84186       };
84187     } catch (std::exception& e) {
84188       {
84189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84190       };
84191     } catch (...) {
84192       {
84193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84194       };
84195     }
84196   }
84197   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
84198   return jresult;
84199 }
84200
84201
84202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
84203   void * jresult ;
84204   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
84205
84206   {
84207     try {
84208       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
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_PageTurnPortraitView__SWIG_1(void * jarg1) {
84229   void * jresult ;
84230   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
84231   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
84232
84233   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
84234   if (!arg1) {
84235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
84236     return 0;
84237   }
84238   {
84239     try {
84240       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView 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_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
84261   void * jresult ;
84262   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
84263   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
84264   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
84265
84266   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
84267   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
84268   if (!arg2) {
84269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
84270     return 0;
84271   }
84272   {
84273     try {
84274       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView 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_PageTurnPortraitView(void * jarg1) {
84295   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
84296
84297   arg1 = (Dali::Toolkit::PageTurnPortraitView *)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_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
84319   void * jresult ;
84320   Dali::Toolkit::PageFactory *arg1 = 0 ;
84321   Dali::Vector2 *arg2 = 0 ;
84322   Dali::Toolkit::PageTurnPortraitView result;
84323
84324   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84325   if (!arg1) {
84326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
84327     return 0;
84328   }
84329   arg2 = (Dali::Vector2 *)jarg2;
84330   if (!arg2) {
84331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
84332     return 0;
84333   }
84334   {
84335     try {
84336       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
84337     } catch (std::out_of_range& e) {
84338       {
84339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84340       };
84341     } catch (std::exception& e) {
84342       {
84343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84344       };
84345     } catch (...) {
84346       {
84347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84348       };
84349     }
84350   }
84351   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
84352   return jresult;
84353 }
84354
84355
84356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
84357   void * jresult ;
84358   Dali::BaseHandle arg1 ;
84359   Dali::BaseHandle *argp1 ;
84360   Dali::Toolkit::PageTurnPortraitView result;
84361
84362   argp1 = (Dali::BaseHandle *)jarg1;
84363   if (!argp1) {
84364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84365     return 0;
84366   }
84367   arg1 = *argp1;
84368   {
84369     try {
84370       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
84371     } catch (std::out_of_range& e) {
84372       {
84373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84374       };
84375     } catch (std::exception& e) {
84376       {
84377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84378       };
84379     } catch (...) {
84380       {
84381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84382       };
84383     }
84384   }
84385   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
84386   return jresult;
84387 }
84388
84389
84390 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
84391   int jresult ;
84392   int result;
84393
84394   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
84395   jresult = (int)result;
84396   return jresult;
84397 }
84398
84399
84400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
84401   int jresult ;
84402   int result;
84403
84404   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
84405   jresult = (int)result;
84406   return jresult;
84407 }
84408
84409
84410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
84411   int jresult ;
84412   int result;
84413
84414   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
84415   jresult = (int)result;
84416   return jresult;
84417 }
84418
84419
84420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
84421   void * jresult ;
84422   Dali::Toolkit::ToggleButton::Property *result = 0 ;
84423
84424   {
84425     try {
84426       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
84427     } catch (std::out_of_range& e) {
84428       {
84429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84430       };
84431     } catch (std::exception& e) {
84432       {
84433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84434       };
84435     } catch (...) {
84436       {
84437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84438       };
84439     }
84440   }
84441   jresult = (void *)result;
84442   return jresult;
84443 }
84444
84445
84446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
84447   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
84448
84449   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
84450   {
84451     try {
84452       delete arg1;
84453     } catch (std::out_of_range& e) {
84454       {
84455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84456       };
84457     } catch (std::exception& e) {
84458       {
84459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84460       };
84461     } catch (...) {
84462       {
84463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84464       };
84465     }
84466   }
84467 }
84468
84469
84470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
84471   void * jresult ;
84472   Dali::Toolkit::ToggleButton *result = 0 ;
84473
84474   {
84475     try {
84476       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
84477     } catch (std::out_of_range& e) {
84478       {
84479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84480       };
84481     } catch (std::exception& e) {
84482       {
84483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84484       };
84485     } catch (...) {
84486       {
84487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84488       };
84489     }
84490   }
84491   jresult = (void *)result;
84492   return jresult;
84493 }
84494
84495
84496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
84497   void * jresult ;
84498   Dali::Toolkit::ToggleButton *arg1 = 0 ;
84499   Dali::Toolkit::ToggleButton *result = 0 ;
84500
84501   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
84502   if (!arg1) {
84503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
84504     return 0;
84505   }
84506   {
84507     try {
84508       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
84509     } catch (std::out_of_range& e) {
84510       {
84511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84512       };
84513     } catch (std::exception& e) {
84514       {
84515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84516       };
84517     } catch (...) {
84518       {
84519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84520       };
84521     }
84522   }
84523   jresult = (void *)result;
84524   return jresult;
84525 }
84526
84527
84528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
84529   void * jresult ;
84530   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
84531   Dali::Toolkit::ToggleButton *arg2 = 0 ;
84532   Dali::Toolkit::ToggleButton *result = 0 ;
84533
84534   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
84535   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
84536   if (!arg2) {
84537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
84538     return 0;
84539   }
84540   {
84541     try {
84542       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
84543     } catch (std::out_of_range& e) {
84544       {
84545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84546       };
84547     } catch (std::exception& e) {
84548       {
84549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84550       };
84551     } catch (...) {
84552       {
84553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84554       };
84555     }
84556   }
84557   jresult = (void *)result;
84558   return jresult;
84559 }
84560
84561
84562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
84563   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
84564
84565   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
84566   {
84567     try {
84568       delete arg1;
84569     } catch (std::out_of_range& e) {
84570       {
84571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84572       };
84573     } catch (std::exception& e) {
84574       {
84575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84576       };
84577     } catch (...) {
84578       {
84579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84580       };
84581     }
84582   }
84583 }
84584
84585
84586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
84587   void * jresult ;
84588   Dali::Toolkit::ToggleButton result;
84589
84590   {
84591     try {
84592       result = Dali::Toolkit::ToggleButton::New();
84593     } catch (std::out_of_range& e) {
84594       {
84595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84596       };
84597     } catch (std::exception& e) {
84598       {
84599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84600       };
84601     } catch (...) {
84602       {
84603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84604       };
84605     }
84606   }
84607   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
84608   return jresult;
84609 }
84610
84611
84612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
84613   void * jresult ;
84614   Dali::BaseHandle arg1 ;
84615   Dali::BaseHandle *argp1 ;
84616   Dali::Toolkit::ToggleButton result;
84617
84618   argp1 = (Dali::BaseHandle *)jarg1;
84619   if (!argp1) {
84620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84621     return 0;
84622   }
84623   arg1 = *argp1;
84624   {
84625     try {
84626       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
84627     } catch (std::out_of_range& e) {
84628       {
84629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84630       };
84631     } catch (std::exception& e) {
84632       {
84633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84634       };
84635     } catch (...) {
84636       {
84637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84638       };
84639     }
84640   }
84641   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
84642   return jresult;
84643 }
84644
84645
84646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
84647   void * jresult ;
84648   Dali::Toolkit::Visual::Base *result = 0 ;
84649
84650   {
84651     try {
84652       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
84653     } catch (std::out_of_range& e) {
84654       {
84655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84656       };
84657     } catch (std::exception& e) {
84658       {
84659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84660       };
84661     } catch (...) {
84662       {
84663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84664       };
84665     }
84666   }
84667   jresult = (void *)result;
84668   return jresult;
84669 }
84670
84671
84672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
84673   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84674
84675   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84676   {
84677     try {
84678       delete arg1;
84679     } catch (std::out_of_range& e) {
84680       {
84681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84682       };
84683     } catch (std::exception& e) {
84684       {
84685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84686       };
84687     } catch (...) {
84688       {
84689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84690       };
84691     }
84692   }
84693 }
84694
84695
84696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
84697   void * jresult ;
84698   Dali::Toolkit::Visual::Base *arg1 = 0 ;
84699   Dali::Toolkit::Visual::Base *result = 0 ;
84700
84701   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84702   if (!arg1) {
84703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
84704     return 0;
84705   }
84706   {
84707     try {
84708       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
84709     } catch (std::out_of_range& e) {
84710       {
84711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84712       };
84713     } catch (std::exception& e) {
84714       {
84715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84716       };
84717     } catch (...) {
84718       {
84719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84720       };
84721     }
84722   }
84723   jresult = (void *)result;
84724   return jresult;
84725 }
84726
84727
84728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
84729   void * jresult ;
84730   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84731   Dali::Toolkit::Visual::Base *arg2 = 0 ;
84732   Dali::Toolkit::Visual::Base *result = 0 ;
84733
84734   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84735   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
84736   if (!arg2) {
84737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
84738     return 0;
84739   }
84740   {
84741     try {
84742       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
84743     } catch (std::out_of_range& e) {
84744       {
84745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84746       };
84747     } catch (std::exception& e) {
84748       {
84749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84750       };
84751     } catch (...) {
84752       {
84753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84754       };
84755     }
84756   }
84757   jresult = (void *)result;
84758   return jresult;
84759 }
84760
84761
84762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
84763   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84764   std::string *arg2 = 0 ;
84765
84766   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84767   if (!jarg2) {
84768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84769     return ;
84770   }
84771   std::string arg2_str(jarg2);
84772   arg2 = &arg2_str;
84773   {
84774     try {
84775       (arg1)->SetName((std::string const &)*arg2);
84776     } catch (std::out_of_range& e) {
84777       {
84778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84779       };
84780     } catch (std::exception& e) {
84781       {
84782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84783       };
84784     } catch (...) {
84785       {
84786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84787       };
84788     }
84789   }
84790
84791   //argout typemap for const std::string&
84792
84793 }
84794
84795
84796 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
84797   char * jresult ;
84798   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84799   std::string *result = 0 ;
84800
84801   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84802   {
84803     try {
84804       result = (std::string *) &(arg1)->GetName();
84805     } catch (std::out_of_range& e) {
84806       {
84807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84808       };
84809     } catch (std::exception& e) {
84810       {
84811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84812       };
84813     } catch (...) {
84814       {
84815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84816       };
84817     }
84818   }
84819   jresult = SWIG_csharp_string_callback(result->c_str());
84820   return jresult;
84821 }
84822
84823
84824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
84825   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84826   Dali::Property::Map *arg2 = 0 ;
84827   Dali::Size arg3 ;
84828   Dali::Size *argp3 ;
84829
84830   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84831   arg2 = (Dali::Property::Map *)jarg2;
84832   if (!arg2) {
84833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
84834     return ;
84835   }
84836   argp3 = (Dali::Size *)jarg3;
84837   if (!argp3) {
84838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
84839     return ;
84840   }
84841   arg3 = *argp3;
84842   {
84843     try {
84844       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
84845     } catch (std::out_of_range& e) {
84846       {
84847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84848       };
84849     } catch (std::exception& e) {
84850       {
84851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84852       };
84853     } catch (...) {
84854       {
84855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84856       };
84857     }
84858   }
84859 }
84860
84861
84862 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
84863   float jresult ;
84864   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84865   float arg2 ;
84866   float result;
84867
84868   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84869   arg2 = (float)jarg2;
84870   {
84871     try {
84872       result = (float)(arg1)->GetHeightForWidth(arg2);
84873     } catch (std::out_of_range& e) {
84874       {
84875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84876       };
84877     } catch (std::exception& e) {
84878       {
84879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84880       };
84881     } catch (...) {
84882       {
84883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84884       };
84885     }
84886   }
84887   jresult = result;
84888   return jresult;
84889 }
84890
84891
84892 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
84893   float jresult ;
84894   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84895   float arg2 ;
84896   float result;
84897
84898   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84899   arg2 = (float)jarg2;
84900   {
84901     try {
84902       result = (float)(arg1)->GetWidthForHeight(arg2);
84903     } catch (std::out_of_range& e) {
84904       {
84905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84906       };
84907     } catch (std::exception& e) {
84908       {
84909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84910       };
84911     } catch (...) {
84912       {
84913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84914       };
84915     }
84916   }
84917   jresult = result;
84918   return jresult;
84919 }
84920
84921
84922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
84923   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84924   Dali::Vector2 *arg2 = 0 ;
84925
84926   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84927   arg2 = (Dali::Vector2 *)jarg2;
84928   if (!arg2) {
84929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
84930     return ;
84931   }
84932   {
84933     try {
84934       (arg1)->GetNaturalSize(*arg2);
84935     } catch (std::out_of_range& e) {
84936       {
84937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84938       };
84939     } catch (std::exception& e) {
84940       {
84941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84942       };
84943     } catch (...) {
84944       {
84945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84946       };
84947     }
84948   }
84949 }
84950
84951
84952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, float jarg2) {
84953   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84954   float arg2 ;
84955
84956   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84957   arg2 = (float)jarg2;
84958   {
84959     try {
84960       (arg1)->SetDepthIndex(arg2);
84961     } catch (std::out_of_range& e) {
84962       {
84963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84964       };
84965     } catch (std::exception& e) {
84966       {
84967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84968       };
84969     } catch (...) {
84970       {
84971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84972       };
84973     }
84974   }
84975 }
84976
84977
84978 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
84979   float jresult ;
84980   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84981   float result;
84982
84983   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84984   {
84985     try {
84986       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
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 = result;
85002   return jresult;
85003 }
85004
85005
85006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
85007   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85008   Dali::Property::Map *arg2 = 0 ;
85009
85010   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85011   arg2 = (Dali::Property::Map *)jarg2;
85012   if (!arg2) {
85013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
85014     return ;
85015   }
85016   {
85017     try {
85018       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
85019     } catch (std::out_of_range& e) {
85020       {
85021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85022       };
85023     } catch (std::exception& e) {
85024       {
85025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85026       };
85027     } catch (...) {
85028       {
85029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85030       };
85031     }
85032   }
85033 }
85034
85035
85036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
85037   void * jresult ;
85038   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
85039   Dali::Toolkit::Visual::Base *result = 0 ;
85040
85041   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
85042   {
85043     try {
85044       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
85045     } catch (std::out_of_range& e) {
85046       {
85047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85048       };
85049     } catch (std::exception& e) {
85050       {
85051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85052       };
85053     } catch (...) {
85054       {
85055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85056       };
85057     }
85058   }
85059   jresult = (void *)result;
85060   return jresult;
85061 }
85062
85063
85064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
85065   void * jresult ;
85066   Dali::Toolkit::VisualFactory result;
85067
85068   {
85069     try {
85070       result = Dali::Toolkit::VisualFactory::Get();
85071     } catch (std::out_of_range& e) {
85072       {
85073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85074       };
85075     } catch (std::exception& e) {
85076       {
85077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85078       };
85079     } catch (...) {
85080       {
85081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85082       };
85083     }
85084   }
85085   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
85086   return jresult;
85087 }
85088
85089
85090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
85091   void * jresult ;
85092   Dali::Toolkit::VisualFactory *result = 0 ;
85093
85094   {
85095     try {
85096       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
85097     } catch (std::out_of_range& e) {
85098       {
85099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85100       };
85101     } catch (std::exception& e) {
85102       {
85103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85104       };
85105     } catch (...) {
85106       {
85107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85108       };
85109     }
85110   }
85111   jresult = (void *)result;
85112   return jresult;
85113 }
85114
85115
85116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
85117   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85118
85119   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85120   {
85121     try {
85122       delete arg1;
85123     } catch (std::out_of_range& e) {
85124       {
85125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85126       };
85127     } catch (std::exception& e) {
85128       {
85129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85130       };
85131     } catch (...) {
85132       {
85133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85134       };
85135     }
85136   }
85137 }
85138
85139
85140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
85141   void * jresult ;
85142   Dali::Toolkit::VisualFactory *arg1 = 0 ;
85143   Dali::Toolkit::VisualFactory *result = 0 ;
85144
85145   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85146   if (!arg1) {
85147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
85148     return 0;
85149   }
85150   {
85151     try {
85152       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
85153     } catch (std::out_of_range& e) {
85154       {
85155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85156       };
85157     } catch (std::exception& e) {
85158       {
85159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85160       };
85161     } catch (...) {
85162       {
85163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85164       };
85165     }
85166   }
85167   jresult = (void *)result;
85168   return jresult;
85169 }
85170
85171
85172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
85173   void * jresult ;
85174   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85175   Dali::Toolkit::VisualFactory *arg2 = 0 ;
85176   Dali::Toolkit::VisualFactory *result = 0 ;
85177
85178   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85179   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
85180   if (!arg2) {
85181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
85182     return 0;
85183   }
85184   {
85185     try {
85186       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
85187     } catch (std::out_of_range& e) {
85188       {
85189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85190       };
85191     } catch (std::exception& e) {
85192       {
85193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85194       };
85195     } catch (...) {
85196       {
85197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85198       };
85199     }
85200   }
85201   jresult = (void *)result;
85202   return jresult;
85203 }
85204
85205
85206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
85207   void * jresult ;
85208   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85209   Dali::Property::Map *arg2 = 0 ;
85210   Dali::Toolkit::Visual::Base result;
85211
85212   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85213   arg2 = (Dali::Property::Map *)jarg2;
85214   if (!arg2) {
85215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
85216     return 0;
85217   }
85218   {
85219     try {
85220       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
85221     } catch (std::out_of_range& e) {
85222       {
85223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85224       };
85225     } catch (std::exception& e) {
85226       {
85227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85228       };
85229     } catch (...) {
85230       {
85231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85232       };
85233     }
85234   }
85235   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
85236   return jresult;
85237 }
85238
85239
85240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
85241   void * jresult ;
85242   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85243   Dali::Image *arg2 = 0 ;
85244   Dali::Toolkit::Visual::Base result;
85245
85246   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85247   arg2 = (Dali::Image *)jarg2;
85248   if (!arg2) {
85249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
85250     return 0;
85251   }
85252   {
85253     try {
85254       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
85255     } catch (std::out_of_range& e) {
85256       {
85257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85258       };
85259     } catch (std::exception& e) {
85260       {
85261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85262       };
85263     } catch (...) {
85264       {
85265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85266       };
85267     }
85268   }
85269   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
85270   return jresult;
85271 }
85272
85273
85274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
85275   void * jresult ;
85276   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85277   std::string *arg2 = 0 ;
85278   Dali::ImageDimensions arg3 ;
85279   Dali::ImageDimensions *argp3 ;
85280   Dali::Toolkit::Visual::Base result;
85281
85282   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85283   if (!jarg2) {
85284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85285     return 0;
85286   }
85287   std::string arg2_str(jarg2);
85288   arg2 = &arg2_str;
85289   argp3 = (Dali::ImageDimensions *)jarg3;
85290   if (!argp3) {
85291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85292     return 0;
85293   }
85294   arg3 = *argp3;
85295   {
85296     try {
85297       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
85298     } catch (std::out_of_range& e) {
85299       {
85300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85301       };
85302     } catch (std::exception& e) {
85303       {
85304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85305       };
85306     } catch (...) {
85307       {
85308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85309       };
85310     }
85311   }
85312   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
85313
85314   //argout typemap for const std::string&
85315
85316   return jresult;
85317 }
85318
85319
85320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
85321   void * jresult ;
85322   Dali::Toolkit::AsyncImageLoader *result = 0 ;
85323
85324   {
85325     try {
85326       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
85327     } catch (std::out_of_range& e) {
85328       {
85329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85330       };
85331     } catch (std::exception& e) {
85332       {
85333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85334       };
85335     } catch (...) {
85336       {
85337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85338       };
85339     }
85340   }
85341   jresult = (void *)result;
85342   return jresult;
85343 }
85344
85345
85346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
85347   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85348
85349   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85350   {
85351     try {
85352       delete arg1;
85353     } catch (std::out_of_range& e) {
85354       {
85355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85356       };
85357     } catch (std::exception& e) {
85358       {
85359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85360       };
85361     } catch (...) {
85362       {
85363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85364       };
85365     }
85366   }
85367 }
85368
85369
85370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
85371   void * jresult ;
85372   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
85373   Dali::Toolkit::AsyncImageLoader *result = 0 ;
85374
85375   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85376   if (!arg1) {
85377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
85378     return 0;
85379   }
85380   {
85381     try {
85382       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
85383     } catch (std::out_of_range& e) {
85384       {
85385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85386       };
85387     } catch (std::exception& e) {
85388       {
85389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85390       };
85391     } catch (...) {
85392       {
85393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85394       };
85395     }
85396   }
85397   jresult = (void *)result;
85398   return jresult;
85399 }
85400
85401
85402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
85403   void * jresult ;
85404   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85405   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
85406   Dali::Toolkit::AsyncImageLoader *result = 0 ;
85407
85408   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85409   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
85410   if (!arg2) {
85411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
85412     return 0;
85413   }
85414   {
85415     try {
85416       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
85417     } catch (std::out_of_range& e) {
85418       {
85419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85420       };
85421     } catch (std::exception& e) {
85422       {
85423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85424       };
85425     } catch (...) {
85426       {
85427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85428       };
85429     }
85430   }
85431   jresult = (void *)result;
85432   return jresult;
85433 }
85434
85435
85436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
85437   void * jresult ;
85438   Dali::Toolkit::AsyncImageLoader result;
85439
85440   {
85441     try {
85442       result = Dali::Toolkit::AsyncImageLoader::New();
85443     } catch (std::out_of_range& e) {
85444       {
85445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85446       };
85447     } catch (std::exception& e) {
85448       {
85449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85450       };
85451     } catch (...) {
85452       {
85453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85454       };
85455     }
85456   }
85457   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
85458   return jresult;
85459 }
85460
85461
85462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
85463   void * jresult ;
85464   Dali::BaseHandle arg1 ;
85465   Dali::BaseHandle *argp1 ;
85466   Dali::Toolkit::AsyncImageLoader result;
85467
85468   argp1 = (Dali::BaseHandle *)jarg1;
85469   if (!argp1) {
85470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85471     return 0;
85472   }
85473   arg1 = *argp1;
85474   {
85475     try {
85476       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
85477     } catch (std::out_of_range& e) {
85478       {
85479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85480       };
85481     } catch (std::exception& e) {
85482       {
85483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85484       };
85485     } catch (...) {
85486       {
85487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85488       };
85489     }
85490   }
85491   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
85492   return jresult;
85493 }
85494
85495
85496 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
85497   unsigned int jresult ;
85498   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85499   std::string *arg2 = 0 ;
85500   uint32_t result;
85501
85502   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85503   if (!jarg2) {
85504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85505     return 0;
85506   }
85507   std::string arg2_str(jarg2);
85508   arg2 = &arg2_str;
85509   {
85510     try {
85511       result = (arg1)->Load((std::string const &)*arg2);
85512     } catch (std::out_of_range& e) {
85513       {
85514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85515       };
85516     } catch (std::exception& e) {
85517       {
85518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85519       };
85520     } catch (...) {
85521       {
85522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85523       };
85524     }
85525   }
85526   jresult = result;
85527
85528   //argout typemap for const std::string&
85529
85530   return jresult;
85531 }
85532
85533
85534 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
85535   unsigned int jresult ;
85536   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85537   std::string *arg2 = 0 ;
85538   Dali::ImageDimensions arg3 ;
85539   Dali::ImageDimensions *argp3 ;
85540   uint32_t result;
85541
85542   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85543   if (!jarg2) {
85544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85545     return 0;
85546   }
85547   std::string arg2_str(jarg2);
85548   arg2 = &arg2_str;
85549   argp3 = (Dali::ImageDimensions *)jarg3;
85550   if (!argp3) {
85551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85552     return 0;
85553   }
85554   arg3 = *argp3;
85555   {
85556     try {
85557       result = (arg1)->Load((std::string const &)*arg2,arg3);
85558     } catch (std::out_of_range& e) {
85559       {
85560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85561       };
85562     } catch (std::exception& e) {
85563       {
85564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85565       };
85566     } catch (...) {
85567       {
85568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85569       };
85570     }
85571   }
85572   jresult = result;
85573
85574   //argout typemap for const std::string&
85575
85576   return jresult;
85577 }
85578
85579
85580 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
85581   unsigned int jresult ;
85582   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85583   std::string *arg2 = 0 ;
85584   Dali::ImageDimensions arg3 ;
85585   Dali::FittingMode::Type arg4 ;
85586   Dali::SamplingMode::Type arg5 ;
85587   bool arg6 ;
85588   Dali::ImageDimensions *argp3 ;
85589   uint32_t result;
85590
85591   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85592   if (!jarg2) {
85593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85594     return 0;
85595   }
85596   std::string arg2_str(jarg2);
85597   arg2 = &arg2_str;
85598   argp3 = (Dali::ImageDimensions *)jarg3;
85599   if (!argp3) {
85600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85601     return 0;
85602   }
85603   arg3 = *argp3;
85604   arg4 = (Dali::FittingMode::Type)jarg4;
85605   arg5 = (Dali::SamplingMode::Type)jarg5;
85606   arg6 = jarg6 ? true : false;
85607   {
85608     try {
85609       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
85610     } catch (std::out_of_range& e) {
85611       {
85612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85613       };
85614     } catch (std::exception& e) {
85615       {
85616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85617       };
85618     } catch (...) {
85619       {
85620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85621       };
85622     }
85623   }
85624   jresult = result;
85625
85626   //argout typemap for const std::string&
85627
85628   return jresult;
85629 }
85630
85631
85632 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
85633   unsigned int jresult ;
85634   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85635   uint32_t arg2 ;
85636   bool result;
85637
85638   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85639   arg2 = (uint32_t)jarg2;
85640   {
85641     try {
85642       result = (bool)(arg1)->Cancel(arg2);
85643     } catch (std::out_of_range& e) {
85644       {
85645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85646       };
85647     } catch (std::exception& e) {
85648       {
85649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85650       };
85651     } catch (...) {
85652       {
85653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85654       };
85655     }
85656   }
85657   jresult = result;
85658   return jresult;
85659 }
85660
85661
85662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
85663   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85664
85665   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85666   {
85667     try {
85668       (arg1)->CancelAll();
85669     } catch (std::out_of_range& e) {
85670       {
85671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85672       };
85673     } catch (std::exception& e) {
85674       {
85675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85676       };
85677     } catch (...) {
85678       {
85679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85680       };
85681     }
85682   }
85683 }
85684
85685
85686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
85687   void * jresult ;
85688   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85689   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
85690
85691   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85692   {
85693     try {
85694       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
85695     } catch (std::out_of_range& e) {
85696       {
85697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85698       };
85699     } catch (std::exception& e) {
85700       {
85701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85702       };
85703     } catch (...) {
85704       {
85705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85706       };
85707     }
85708   }
85709   jresult = (void *)result;
85710   return jresult;
85711 }
85712
85713
85714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_2(void * jarg1) {
85715   void * jresult ;
85716   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
85717   Dali::Toolkit::AsyncImageLoader *result = 0 ;
85718
85719   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
85720   {
85721     try {
85722       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
85723     } catch (std::out_of_range& e) {
85724       {
85725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85726       };
85727     } catch (std::exception& e) {
85728       {
85729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85730       };
85731     } catch (...) {
85732       {
85733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85734       };
85735     }
85736   }
85737   jresult = (void *)result;
85738   return jresult;
85739 }
85740
85741
85742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
85743   void * jresult ;
85744   std::string *arg1 = 0 ;
85745   Dali::PixelData result;
85746
85747   if (!jarg1) {
85748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85749     return 0;
85750   }
85751   std::string arg1_str(jarg1);
85752   arg1 = &arg1_str;
85753   {
85754     try {
85755       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
85756     } catch (std::out_of_range& e) {
85757       {
85758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85759       };
85760     } catch (std::exception& e) {
85761       {
85762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85763       };
85764     } catch (...) {
85765       {
85766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85767       };
85768     }
85769   }
85770   jresult = new Dali::PixelData((const Dali::PixelData &)result);
85771
85772   //argout typemap for const std::string&
85773
85774   return jresult;
85775 }
85776
85777
85778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
85779   void * jresult ;
85780   std::string *arg1 = 0 ;
85781   Dali::ImageDimensions arg2 ;
85782   Dali::ImageDimensions *argp2 ;
85783   Dali::PixelData result;
85784
85785   if (!jarg1) {
85786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85787     return 0;
85788   }
85789   std::string arg1_str(jarg1);
85790   arg1 = &arg1_str;
85791   argp2 = (Dali::ImageDimensions *)jarg2;
85792   if (!argp2) {
85793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85794     return 0;
85795   }
85796   arg2 = *argp2;
85797   {
85798     try {
85799       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
85800     } catch (std::out_of_range& e) {
85801       {
85802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85803       };
85804     } catch (std::exception& e) {
85805       {
85806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85807       };
85808     } catch (...) {
85809       {
85810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85811       };
85812     }
85813   }
85814   jresult = new Dali::PixelData((const Dali::PixelData &)result);
85815
85816   //argout typemap for const std::string&
85817
85818   return jresult;
85819 }
85820
85821
85822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
85823   void * jresult ;
85824   std::string *arg1 = 0 ;
85825   Dali::ImageDimensions arg2 ;
85826   Dali::FittingMode::Type arg3 ;
85827   Dali::SamplingMode::Type arg4 ;
85828   bool arg5 ;
85829   Dali::ImageDimensions *argp2 ;
85830   Dali::PixelData result;
85831
85832   if (!jarg1) {
85833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85834     return 0;
85835   }
85836   std::string arg1_str(jarg1);
85837   arg1 = &arg1_str;
85838   argp2 = (Dali::ImageDimensions *)jarg2;
85839   if (!argp2) {
85840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85841     return 0;
85842   }
85843   arg2 = *argp2;
85844   arg3 = (Dali::FittingMode::Type)jarg3;
85845   arg4 = (Dali::SamplingMode::Type)jarg4;
85846   arg5 = jarg5 ? true : false;
85847   {
85848     try {
85849       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
85850     } catch (std::out_of_range& e) {
85851       {
85852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85853       };
85854     } catch (std::exception& e) {
85855       {
85856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85857       };
85858     } catch (...) {
85859       {
85860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85861       };
85862     }
85863   }
85864   jresult = new Dali::PixelData((const Dali::PixelData &)result);
85865
85866   //argout typemap for const std::string&
85867
85868   return jresult;
85869 }
85870
85871
85872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
85873   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
85874
85875   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
85876   {
85877     try {
85878       delete arg1;
85879     } catch (std::out_of_range& e) {
85880       {
85881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85882       };
85883     } catch (std::exception& e) {
85884       {
85885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85886       };
85887     } catch (...) {
85888       {
85889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85890       };
85891     }
85892   }
85893 }
85894
85895
85896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
85897   void * jresult ;
85898   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
85899   Dali::Actor arg2 ;
85900   Dali::Actor arg3 ;
85901   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
85902   Dali::Actor *argp2 ;
85903   Dali::Actor *argp3 ;
85904   Dali::Actor result;
85905
85906   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
85907   argp2 = (Dali::Actor *)jarg2;
85908   if (!argp2) {
85909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85910     return 0;
85911   }
85912   arg2 = *argp2;
85913   argp3 = (Dali::Actor *)jarg3;
85914   if (!argp3) {
85915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85916     return 0;
85917   }
85918   arg3 = *argp3;
85919   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
85920   {
85921     try {
85922       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
85923     } catch (std::out_of_range& e) {
85924       {
85925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85926       };
85927     } catch (std::exception& e) {
85928       {
85929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85930       };
85931     } catch (...) {
85932       {
85933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85934       };
85935     }
85936   }
85937   jresult = new Dali::Actor((const Dali::Actor &)result);
85938   return jresult;
85939 }
85940
85941
85942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
85943   void * jresult ;
85944   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
85945
85946   {
85947     try {
85948       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
85949     } catch (std::out_of_range& e) {
85950       {
85951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85952       };
85953     } catch (std::exception& e) {
85954       {
85955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85956       };
85957     } catch (...) {
85958       {
85959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85960       };
85961     }
85962   }
85963   jresult = (void *)result;
85964   return jresult;
85965 }
85966
85967
85968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
85969   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
85970   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
85971   if (director) {
85972     director->swig_connect_director(callback0);
85973   }
85974 }
85975
85976
85977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
85978   KeyboardFocusManager arg1 ;
85979   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
85980   KeyboardFocusManager *argp1 ;
85981
85982   argp1 = (KeyboardFocusManager *)jarg1;
85983   if (!argp1) {
85984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
85985     return ;
85986   }
85987   arg1 = *argp1;
85988   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
85989   if (!arg2) {
85990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
85991     return ;
85992   }
85993   {
85994     try {
85995       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
85996     } catch (std::out_of_range& e) {
85997       {
85998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85999       };
86000     } catch (std::exception& e) {
86001       {
86002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86003       };
86004     } catch (...) {
86005       {
86006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86007       };
86008     }
86009   }
86010 }
86011
86012
86013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
86014   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86015
86016   arg1 = (std::vector< unsigned int > *)jarg1;
86017   {
86018     try {
86019       (arg1)->clear();
86020     } catch (std::out_of_range& e) {
86021       {
86022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86023       };
86024     } catch (std::exception& e) {
86025       {
86026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86027       };
86028     } catch (...) {
86029       {
86030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86031       };
86032     }
86033   }
86034 }
86035
86036
86037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
86038   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86039   unsigned int *arg2 = 0 ;
86040   unsigned int temp2 ;
86041
86042   arg1 = (std::vector< unsigned int > *)jarg1;
86043   temp2 = (unsigned int)jarg2;
86044   arg2 = &temp2;
86045   {
86046     try {
86047       (arg1)->push_back((unsigned int const &)*arg2);
86048     } catch (std::out_of_range& e) {
86049       {
86050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86051       };
86052     } catch (std::exception& e) {
86053       {
86054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86055       };
86056     } catch (...) {
86057       {
86058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86059       };
86060     }
86061   }
86062 }
86063
86064
86065 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
86066   unsigned long jresult ;
86067   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86068   std::vector< unsigned int >::size_type result;
86069
86070   arg1 = (std::vector< unsigned int > *)jarg1;
86071   {
86072     try {
86073       result = ((std::vector< unsigned int > const *)arg1)->size();
86074     } catch (std::out_of_range& e) {
86075       {
86076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86077       };
86078     } catch (std::exception& e) {
86079       {
86080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86081       };
86082     } catch (...) {
86083       {
86084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86085       };
86086     }
86087   }
86088   jresult = (unsigned long)result;
86089   return jresult;
86090 }
86091
86092
86093 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
86094   unsigned long jresult ;
86095   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86096   std::vector< unsigned int >::size_type result;
86097
86098   arg1 = (std::vector< unsigned int > *)jarg1;
86099   {
86100     try {
86101       result = ((std::vector< unsigned int > const *)arg1)->capacity();
86102     } catch (std::out_of_range& e) {
86103       {
86104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86105       };
86106     } catch (std::exception& e) {
86107       {
86108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86109       };
86110     } catch (...) {
86111       {
86112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86113       };
86114     }
86115   }
86116   jresult = (unsigned long)result;
86117   return jresult;
86118 }
86119
86120
86121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
86122   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86123   std::vector< unsigned int >::size_type arg2 ;
86124
86125   arg1 = (std::vector< unsigned int > *)jarg1;
86126   arg2 = (std::vector< unsigned int >::size_type)jarg2;
86127   {
86128     try {
86129       (arg1)->reserve(arg2);
86130     } catch (std::out_of_range& e) {
86131       {
86132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86133       };
86134     } catch (std::exception& e) {
86135       {
86136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86137       };
86138     } catch (...) {
86139       {
86140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86141       };
86142     }
86143   }
86144 }
86145
86146
86147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
86148   void * jresult ;
86149   std::vector< unsigned int > *result = 0 ;
86150
86151   {
86152     try {
86153       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
86154     } catch (std::out_of_range& e) {
86155       {
86156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86157       };
86158     } catch (std::exception& e) {
86159       {
86160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86161       };
86162     } catch (...) {
86163       {
86164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86165       };
86166     }
86167   }
86168   jresult = (void *)result;
86169   return jresult;
86170 }
86171
86172
86173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
86174   void * jresult ;
86175   std::vector< unsigned int > *arg1 = 0 ;
86176   std::vector< unsigned int > *result = 0 ;
86177
86178   arg1 = (std::vector< unsigned int > *)jarg1;
86179   if (!arg1) {
86180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
86181     return 0;
86182   }
86183   {
86184     try {
86185       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
86186     } catch (std::out_of_range& e) {
86187       {
86188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86189       };
86190     } catch (std::exception& e) {
86191       {
86192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86193       };
86194     } catch (...) {
86195       {
86196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86197       };
86198     }
86199   }
86200   jresult = (void *)result;
86201   return jresult;
86202 }
86203
86204
86205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
86206   void * jresult ;
86207   int arg1 ;
86208   std::vector< unsigned int > *result = 0 ;
86209
86210   arg1 = (int)jarg1;
86211   {
86212     try {
86213       try {
86214         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
86215       }
86216       catch(std::out_of_range &_e) {
86217         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86218         return 0;
86219       }
86220
86221     } catch (std::out_of_range& e) {
86222       {
86223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86224       };
86225     } catch (std::exception& e) {
86226       {
86227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86228       };
86229     } catch (...) {
86230       {
86231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86232       };
86233     }
86234   }
86235   jresult = (void *)result;
86236   return jresult;
86237 }
86238
86239
86240 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
86241   unsigned int jresult ;
86242   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86243   int arg2 ;
86244   unsigned int result;
86245
86246   arg1 = (std::vector< unsigned int > *)jarg1;
86247   arg2 = (int)jarg2;
86248   {
86249     try {
86250       try {
86251         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
86252       }
86253       catch(std::out_of_range &_e) {
86254         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86255         return 0;
86256       }
86257
86258     } catch (std::out_of_range& e) {
86259       {
86260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86261       };
86262     } catch (std::exception& e) {
86263       {
86264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86265       };
86266     } catch (...) {
86267       {
86268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86269       };
86270     }
86271   }
86272   jresult = result;
86273   return jresult;
86274 }
86275
86276
86277 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
86278   unsigned int jresult ;
86279   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86280   int arg2 ;
86281   unsigned int *result = 0 ;
86282
86283   arg1 = (std::vector< unsigned int > *)jarg1;
86284   arg2 = (int)jarg2;
86285   {
86286     try {
86287       try {
86288         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
86289       }
86290       catch(std::out_of_range &_e) {
86291         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86292         return 0;
86293       }
86294
86295     } catch (std::out_of_range& e) {
86296       {
86297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86298       };
86299     } catch (std::exception& e) {
86300       {
86301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86302       };
86303     } catch (...) {
86304       {
86305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86306       };
86307     }
86308   }
86309   jresult = *result;
86310   return jresult;
86311 }
86312
86313
86314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
86315   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86316   int arg2 ;
86317   unsigned int *arg3 = 0 ;
86318   unsigned int temp3 ;
86319
86320   arg1 = (std::vector< unsigned int > *)jarg1;
86321   arg2 = (int)jarg2;
86322   temp3 = (unsigned int)jarg3;
86323   arg3 = &temp3;
86324   {
86325     try {
86326       try {
86327         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
86328       }
86329       catch(std::out_of_range &_e) {
86330         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86331         return ;
86332       }
86333
86334     } catch (std::out_of_range& e) {
86335       {
86336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86337       };
86338     } catch (std::exception& e) {
86339       {
86340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86341       };
86342     } catch (...) {
86343       {
86344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86345       };
86346     }
86347   }
86348 }
86349
86350
86351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
86352   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86353   std::vector< unsigned int > *arg2 = 0 ;
86354
86355   arg1 = (std::vector< unsigned int > *)jarg1;
86356   arg2 = (std::vector< unsigned int > *)jarg2;
86357   if (!arg2) {
86358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
86359     return ;
86360   }
86361   {
86362     try {
86363       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
86364     } catch (std::out_of_range& e) {
86365       {
86366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86367       };
86368     } catch (std::exception& e) {
86369       {
86370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86371       };
86372     } catch (...) {
86373       {
86374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86375       };
86376     }
86377   }
86378 }
86379
86380
86381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
86382   void * jresult ;
86383   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86384   int arg2 ;
86385   int arg3 ;
86386   std::vector< unsigned int > *result = 0 ;
86387
86388   arg1 = (std::vector< unsigned int > *)jarg1;
86389   arg2 = (int)jarg2;
86390   arg3 = (int)jarg3;
86391   {
86392     try {
86393       try {
86394         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
86395       }
86396       catch(std::out_of_range &_e) {
86397         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86398         return 0;
86399       }
86400       catch(std::invalid_argument &_e) {
86401         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
86402         return 0;
86403       }
86404
86405     } catch (std::out_of_range& e) {
86406       {
86407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86408       };
86409     } catch (std::exception& e) {
86410       {
86411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86412       };
86413     } catch (...) {
86414       {
86415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86416       };
86417     }
86418   }
86419   jresult = (void *)result;
86420   return jresult;
86421 }
86422
86423
86424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
86425   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86426   int arg2 ;
86427   unsigned int *arg3 = 0 ;
86428   unsigned int temp3 ;
86429
86430   arg1 = (std::vector< unsigned int > *)jarg1;
86431   arg2 = (int)jarg2;
86432   temp3 = (unsigned int)jarg3;
86433   arg3 = &temp3;
86434   {
86435     try {
86436       try {
86437         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
86438       }
86439       catch(std::out_of_range &_e) {
86440         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86441         return ;
86442       }
86443
86444     } catch (std::out_of_range& e) {
86445       {
86446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86447       };
86448     } catch (std::exception& e) {
86449       {
86450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86451       };
86452     } catch (...) {
86453       {
86454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86455       };
86456     }
86457   }
86458 }
86459
86460
86461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
86462   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86463   int arg2 ;
86464   std::vector< unsigned int > *arg3 = 0 ;
86465
86466   arg1 = (std::vector< unsigned int > *)jarg1;
86467   arg2 = (int)jarg2;
86468   arg3 = (std::vector< unsigned int > *)jarg3;
86469   if (!arg3) {
86470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
86471     return ;
86472   }
86473   {
86474     try {
86475       try {
86476         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
86477       }
86478       catch(std::out_of_range &_e) {
86479         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86480         return ;
86481       }
86482
86483     } catch (std::out_of_range& e) {
86484       {
86485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86486       };
86487     } catch (std::exception& e) {
86488       {
86489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86490       };
86491     } catch (...) {
86492       {
86493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86494       };
86495     }
86496   }
86497 }
86498
86499
86500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
86501   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86502   int arg2 ;
86503
86504   arg1 = (std::vector< unsigned int > *)jarg1;
86505   arg2 = (int)jarg2;
86506   {
86507     try {
86508       try {
86509         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
86510       }
86511       catch(std::out_of_range &_e) {
86512         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86513         return ;
86514       }
86515
86516     } catch (std::out_of_range& e) {
86517       {
86518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86519       };
86520     } catch (std::exception& e) {
86521       {
86522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86523       };
86524     } catch (...) {
86525       {
86526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86527       };
86528     }
86529   }
86530 }
86531
86532
86533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
86534   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86535   int arg2 ;
86536   int arg3 ;
86537
86538   arg1 = (std::vector< unsigned int > *)jarg1;
86539   arg2 = (int)jarg2;
86540   arg3 = (int)jarg3;
86541   {
86542     try {
86543       try {
86544         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
86545       }
86546       catch(std::out_of_range &_e) {
86547         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86548         return ;
86549       }
86550       catch(std::invalid_argument &_e) {
86551         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
86552         return ;
86553       }
86554
86555     } catch (std::out_of_range& e) {
86556       {
86557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86558       };
86559     } catch (std::exception& e) {
86560       {
86561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86562       };
86563     } catch (...) {
86564       {
86565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86566       };
86567     }
86568   }
86569 }
86570
86571
86572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
86573   void * jresult ;
86574   unsigned int *arg1 = 0 ;
86575   int arg2 ;
86576   unsigned int temp1 ;
86577   std::vector< unsigned int > *result = 0 ;
86578
86579   temp1 = (unsigned int)jarg1;
86580   arg1 = &temp1;
86581   arg2 = (int)jarg2;
86582   {
86583     try {
86584       try {
86585         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
86586       }
86587       catch(std::out_of_range &_e) {
86588         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86589         return 0;
86590       }
86591
86592     } catch (std::out_of_range& e) {
86593       {
86594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86595       };
86596     } catch (std::exception& e) {
86597       {
86598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86599       };
86600     } catch (...) {
86601       {
86602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86603       };
86604     }
86605   }
86606   jresult = (void *)result;
86607   return jresult;
86608 }
86609
86610
86611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
86612   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86613
86614   arg1 = (std::vector< unsigned int > *)jarg1;
86615   {
86616     try {
86617       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
86618     } catch (std::out_of_range& e) {
86619       {
86620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86621       };
86622     } catch (std::exception& e) {
86623       {
86624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86625       };
86626     } catch (...) {
86627       {
86628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86629       };
86630     }
86631   }
86632 }
86633
86634
86635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
86636   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86637   int arg2 ;
86638   int arg3 ;
86639
86640   arg1 = (std::vector< unsigned int > *)jarg1;
86641   arg2 = (int)jarg2;
86642   arg3 = (int)jarg3;
86643   {
86644     try {
86645       try {
86646         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
86647       }
86648       catch(std::out_of_range &_e) {
86649         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86650         return ;
86651       }
86652       catch(std::invalid_argument &_e) {
86653         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
86654         return ;
86655       }
86656
86657     } catch (std::out_of_range& e) {
86658       {
86659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86660       };
86661     } catch (std::exception& e) {
86662       {
86663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86664       };
86665     } catch (...) {
86666       {
86667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86668       };
86669     }
86670   }
86671 }
86672
86673
86674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
86675   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86676   int arg2 ;
86677   std::vector< unsigned int > *arg3 = 0 ;
86678
86679   arg1 = (std::vector< unsigned int > *)jarg1;
86680   arg2 = (int)jarg2;
86681   arg3 = (std::vector< unsigned int > *)jarg3;
86682   if (!arg3) {
86683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
86684     return ;
86685   }
86686   {
86687     try {
86688       try {
86689         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
86690       }
86691       catch(std::out_of_range &_e) {
86692         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86693         return ;
86694       }
86695
86696     } catch (std::out_of_range& e) {
86697       {
86698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86699       };
86700     } catch (std::exception& e) {
86701       {
86702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86703       };
86704     } catch (...) {
86705       {
86706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86707       };
86708     }
86709   }
86710 }
86711
86712
86713 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
86714   unsigned int jresult ;
86715   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86716   unsigned int *arg2 = 0 ;
86717   unsigned int temp2 ;
86718   bool result;
86719
86720   arg1 = (std::vector< unsigned int > *)jarg1;
86721   temp2 = (unsigned int)jarg2;
86722   arg2 = &temp2;
86723   {
86724     try {
86725       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
86726     } catch (std::out_of_range& e) {
86727       {
86728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86729       };
86730     } catch (std::exception& e) {
86731       {
86732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86733       };
86734     } catch (...) {
86735       {
86736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86737       };
86738     }
86739   }
86740   jresult = result;
86741   return jresult;
86742 }
86743
86744
86745 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
86746   int jresult ;
86747   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86748   unsigned int *arg2 = 0 ;
86749   unsigned int temp2 ;
86750   int result;
86751
86752   arg1 = (std::vector< unsigned int > *)jarg1;
86753   temp2 = (unsigned int)jarg2;
86754   arg2 = &temp2;
86755   {
86756     try {
86757       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
86758     } catch (std::out_of_range& e) {
86759       {
86760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86761       };
86762     } catch (std::exception& e) {
86763       {
86764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86765       };
86766     } catch (...) {
86767       {
86768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86769       };
86770     }
86771   }
86772   jresult = result;
86773   return jresult;
86774 }
86775
86776
86777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
86778   int jresult ;
86779   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86780   unsigned int *arg2 = 0 ;
86781   unsigned int temp2 ;
86782   int result;
86783
86784   arg1 = (std::vector< unsigned int > *)jarg1;
86785   temp2 = (unsigned int)jarg2;
86786   arg2 = &temp2;
86787   {
86788     try {
86789       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
86790     } catch (std::out_of_range& e) {
86791       {
86792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86793       };
86794     } catch (std::exception& e) {
86795       {
86796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86797       };
86798     } catch (...) {
86799       {
86800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86801       };
86802     }
86803   }
86804   jresult = result;
86805   return jresult;
86806 }
86807
86808
86809 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
86810   unsigned int jresult ;
86811   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86812   unsigned int *arg2 = 0 ;
86813   unsigned int temp2 ;
86814   bool result;
86815
86816   arg1 = (std::vector< unsigned int > *)jarg1;
86817   temp2 = (unsigned int)jarg2;
86818   arg2 = &temp2;
86819   {
86820     try {
86821       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
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 = result;
86837   return jresult;
86838 }
86839
86840
86841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
86842   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86843
86844   arg1 = (std::vector< unsigned int > *)jarg1;
86845   {
86846     try {
86847       delete arg1;
86848     } catch (std::out_of_range& e) {
86849       {
86850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86851       };
86852     } catch (std::exception& e) {
86853       {
86854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86855       };
86856     } catch (...) {
86857       {
86858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86859       };
86860     }
86861   }
86862 }
86863
86864
86865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
86866   void * jresult ;
86867   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86868
86869   {
86870     try {
86871       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
86872     } catch (std::out_of_range& e) {
86873       {
86874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86875       };
86876     } catch (std::exception& e) {
86877       {
86878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86879       };
86880     } catch (...) {
86881       {
86882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86883       };
86884     }
86885   }
86886   jresult = (void *)result;
86887   return jresult;
86888 }
86889
86890
86891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
86892   void * jresult ;
86893   unsigned int arg1 ;
86894   Dali::Actor arg2 ;
86895   Dali::Actor *argp2 ;
86896   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86897
86898   arg1 = (unsigned int)jarg1;
86899   argp2 = (Dali::Actor *)jarg2;
86900   if (!argp2) {
86901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86902     return 0;
86903   }
86904   arg2 = *argp2;
86905   {
86906     try {
86907       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
86908     } catch (std::out_of_range& e) {
86909       {
86910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86911       };
86912     } catch (std::exception& e) {
86913       {
86914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86915       };
86916     } catch (...) {
86917       {
86918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86919       };
86920     }
86921   }
86922   jresult = (void *)result;
86923   return jresult;
86924 }
86925
86926
86927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
86928   void * jresult ;
86929   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
86930   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86931
86932   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86933   if (!arg1) {
86934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
86935     return 0;
86936   }
86937   {
86938     try {
86939       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
86940     } catch (std::out_of_range& e) {
86941       {
86942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86943       };
86944     } catch (std::exception& e) {
86945       {
86946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86947       };
86948     } catch (...) {
86949       {
86950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86951       };
86952     }
86953   }
86954   jresult = (void *)result;
86955   return jresult;
86956 }
86957
86958
86959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
86960   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86961   unsigned int arg2 ;
86962
86963   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86964   arg2 = (unsigned int)jarg2;
86965   if (arg1) (arg1)->first = arg2;
86966 }
86967
86968
86969 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
86970   unsigned int jresult ;
86971   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86972   unsigned int result;
86973
86974   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86975   result = (unsigned int) ((arg1)->first);
86976   jresult = result;
86977   return jresult;
86978 }
86979
86980
86981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
86982   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86983   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
86984
86985   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86986   arg2 = (Dali::Actor *)jarg2;
86987   if (arg1) (arg1)->second = *arg2;
86988 }
86989
86990
86991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
86992   void * jresult ;
86993   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86994   Dali::Actor *result = 0 ;
86995
86996   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86997   result = (Dali::Actor *)& ((arg1)->second);
86998   jresult = (void *)result;
86999   return jresult;
87000 }
87001
87002
87003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
87004   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
87005
87006   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87007   {
87008     try {
87009       delete arg1;
87010     } catch (std::out_of_range& e) {
87011       {
87012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87013       };
87014     } catch (std::exception& e) {
87015       {
87016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87017       };
87018     } catch (...) {
87019       {
87020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87021       };
87022     }
87023   }
87024 }
87025
87026
87027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
87028   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87029
87030   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87031   {
87032     try {
87033       (arg1)->clear();
87034     } catch (std::out_of_range& e) {
87035       {
87036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87037       };
87038     } catch (std::exception& e) {
87039       {
87040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87041       };
87042     } catch (...) {
87043       {
87044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87045       };
87046     }
87047   }
87048 }
87049
87050
87051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
87052   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87053   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
87054
87055   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87056   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
87057   if (!arg2) {
87058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87059     return ;
87060   }
87061   {
87062     try {
87063       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
87064     } catch (std::out_of_range& e) {
87065       {
87066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87067       };
87068     } catch (std::exception& e) {
87069       {
87070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87071       };
87072     } catch (...) {
87073       {
87074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87075       };
87076     }
87077   }
87078 }
87079
87080
87081 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
87082   unsigned long jresult ;
87083   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87084   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
87085
87086   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87087   {
87088     try {
87089       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
87090     } catch (std::out_of_range& e) {
87091       {
87092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87093       };
87094     } catch (std::exception& e) {
87095       {
87096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87097       };
87098     } catch (...) {
87099       {
87100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87101       };
87102     }
87103   }
87104   jresult = (unsigned long)result;
87105   return jresult;
87106 }
87107
87108
87109 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
87110   unsigned long jresult ;
87111   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87112   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
87113
87114   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87115   {
87116     try {
87117       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
87118     } catch (std::out_of_range& e) {
87119       {
87120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87121       };
87122     } catch (std::exception& e) {
87123       {
87124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87125       };
87126     } catch (...) {
87127       {
87128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87129       };
87130     }
87131   }
87132   jresult = (unsigned long)result;
87133   return jresult;
87134 }
87135
87136
87137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
87138   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87139   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
87140
87141   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87142   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
87143   {
87144     try {
87145       (arg1)->reserve(arg2);
87146     } catch (std::out_of_range& e) {
87147       {
87148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87149       };
87150     } catch (std::exception& e) {
87151       {
87152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87153       };
87154     } catch (...) {
87155       {
87156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87157       };
87158     }
87159   }
87160 }
87161
87162
87163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
87164   void * jresult ;
87165   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87166
87167   {
87168     try {
87169       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
87170     } catch (std::out_of_range& e) {
87171       {
87172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87173       };
87174     } catch (std::exception& e) {
87175       {
87176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87177       };
87178     } catch (...) {
87179       {
87180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87181       };
87182     }
87183   }
87184   jresult = (void *)result;
87185   return jresult;
87186 }
87187
87188
87189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
87190   void * jresult ;
87191   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
87192   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87193
87194   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87195   if (!arg1) {
87196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
87197     return 0;
87198   }
87199   {
87200     try {
87201       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);
87202     } catch (std::out_of_range& e) {
87203       {
87204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87205       };
87206     } catch (std::exception& e) {
87207       {
87208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87209       };
87210     } catch (...) {
87211       {
87212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87213       };
87214     }
87215   }
87216   jresult = (void *)result;
87217   return jresult;
87218 }
87219
87220
87221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
87222   void * jresult ;
87223   int arg1 ;
87224   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87225
87226   arg1 = (int)jarg1;
87227   {
87228     try {
87229       try {
87230         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);
87231       }
87232       catch(std::out_of_range &_e) {
87233         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87234         return 0;
87235       }
87236
87237     } catch (std::out_of_range& e) {
87238       {
87239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87240       };
87241     } catch (std::exception& e) {
87242       {
87243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87244       };
87245     } catch (...) {
87246       {
87247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87248       };
87249     }
87250   }
87251   jresult = (void *)result;
87252   return jresult;
87253 }
87254
87255
87256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
87257   void * jresult ;
87258   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87259   int arg2 ;
87260   std::pair< unsigned int,Dali::Actor > result;
87261
87262   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87263   arg2 = (int)jarg2;
87264   {
87265     try {
87266       try {
87267         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
87268       }
87269       catch(std::out_of_range &_e) {
87270         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87271         return 0;
87272       }
87273
87274     } catch (std::out_of_range& e) {
87275       {
87276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87277       };
87278     } catch (std::exception& e) {
87279       {
87280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87281       };
87282     } catch (...) {
87283       {
87284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87285       };
87286     }
87287   }
87288   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
87289   return jresult;
87290 }
87291
87292
87293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
87294   void * jresult ;
87295   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87296   int arg2 ;
87297   std::pair< unsigned int,Dali::Actor > *result = 0 ;
87298
87299   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87300   arg2 = (int)jarg2;
87301   {
87302     try {
87303       try {
87304         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
87305       }
87306       catch(std::out_of_range &_e) {
87307         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87308         return 0;
87309       }
87310
87311     } catch (std::out_of_range& e) {
87312       {
87313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87314       };
87315     } catch (std::exception& e) {
87316       {
87317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87318       };
87319     } catch (...) {
87320       {
87321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87322       };
87323     }
87324   }
87325   jresult = (void *)result;
87326   return jresult;
87327 }
87328
87329
87330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
87331   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87332   int arg2 ;
87333   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
87334
87335   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87336   arg2 = (int)jarg2;
87337   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
87338   if (!arg3) {
87339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87340     return ;
87341   }
87342   {
87343     try {
87344       try {
87345         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);
87346       }
87347       catch(std::out_of_range &_e) {
87348         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87349         return ;
87350       }
87351
87352     } catch (std::out_of_range& e) {
87353       {
87354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87355       };
87356     } catch (std::exception& e) {
87357       {
87358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87359       };
87360     } catch (...) {
87361       {
87362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87363       };
87364     }
87365   }
87366 }
87367
87368
87369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
87370   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87371   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
87372
87373   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87374   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
87375   if (!arg2) {
87376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
87377     return ;
87378   }
87379   {
87380     try {
87381       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);
87382     } catch (std::out_of_range& e) {
87383       {
87384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87385       };
87386     } catch (std::exception& e) {
87387       {
87388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87389       };
87390     } catch (...) {
87391       {
87392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87393       };
87394     }
87395   }
87396 }
87397
87398
87399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
87400   void * jresult ;
87401   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87402   int arg2 ;
87403   int arg3 ;
87404   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87405
87406   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87407   arg2 = (int)jarg2;
87408   arg3 = (int)jarg3;
87409   {
87410     try {
87411       try {
87412         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);
87413       }
87414       catch(std::out_of_range &_e) {
87415         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87416         return 0;
87417       }
87418       catch(std::invalid_argument &_e) {
87419         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87420         return 0;
87421       }
87422
87423     } catch (std::out_of_range& e) {
87424       {
87425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87426       };
87427     } catch (std::exception& e) {
87428       {
87429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87430       };
87431     } catch (...) {
87432       {
87433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87434       };
87435     }
87436   }
87437   jresult = (void *)result;
87438   return jresult;
87439 }
87440
87441
87442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
87443   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87444   int arg2 ;
87445   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
87446
87447   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87448   arg2 = (int)jarg2;
87449   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
87450   if (!arg3) {
87451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87452     return ;
87453   }
87454   {
87455     try {
87456       try {
87457         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);
87458       }
87459       catch(std::out_of_range &_e) {
87460         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87461         return ;
87462       }
87463
87464     } catch (std::out_of_range& e) {
87465       {
87466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87467       };
87468     } catch (std::exception& e) {
87469       {
87470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87471       };
87472     } catch (...) {
87473       {
87474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87475       };
87476     }
87477   }
87478 }
87479
87480
87481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
87482   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87483   int arg2 ;
87484   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
87485
87486   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87487   arg2 = (int)jarg2;
87488   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
87489   if (!arg3) {
87490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
87491     return ;
87492   }
87493   {
87494     try {
87495       try {
87496         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);
87497       }
87498       catch(std::out_of_range &_e) {
87499         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87500         return ;
87501       }
87502
87503     } catch (std::out_of_range& e) {
87504       {
87505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87506       };
87507     } catch (std::exception& e) {
87508       {
87509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87510       };
87511     } catch (...) {
87512       {
87513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87514       };
87515     }
87516   }
87517 }
87518
87519
87520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
87521   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87522   int arg2 ;
87523
87524   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87525   arg2 = (int)jarg2;
87526   {
87527     try {
87528       try {
87529         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
87530       }
87531       catch(std::out_of_range &_e) {
87532         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87533         return ;
87534       }
87535
87536     } catch (std::out_of_range& e) {
87537       {
87538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87539       };
87540     } catch (std::exception& e) {
87541       {
87542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87543       };
87544     } catch (...) {
87545       {
87546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87547       };
87548     }
87549   }
87550 }
87551
87552
87553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
87554   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87555   int arg2 ;
87556   int arg3 ;
87557
87558   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87559   arg2 = (int)jarg2;
87560   arg3 = (int)jarg3;
87561   {
87562     try {
87563       try {
87564         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
87565       }
87566       catch(std::out_of_range &_e) {
87567         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87568         return ;
87569       }
87570       catch(std::invalid_argument &_e) {
87571         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87572         return ;
87573       }
87574
87575     } catch (std::out_of_range& e) {
87576       {
87577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87578       };
87579     } catch (std::exception& e) {
87580       {
87581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87582       };
87583     } catch (...) {
87584       {
87585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87586       };
87587     }
87588   }
87589 }
87590
87591
87592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
87593   void * jresult ;
87594   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
87595   int arg2 ;
87596   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87597
87598   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87599   if (!arg1) {
87600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87601     return 0;
87602   }
87603   arg2 = (int)jarg2;
87604   {
87605     try {
87606       try {
87607         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);
87608       }
87609       catch(std::out_of_range &_e) {
87610         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87611         return 0;
87612       }
87613
87614     } catch (std::out_of_range& e) {
87615       {
87616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87617       };
87618     } catch (std::exception& e) {
87619       {
87620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87621       };
87622     } catch (...) {
87623       {
87624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87625       };
87626     }
87627   }
87628   jresult = (void *)result;
87629   return jresult;
87630 }
87631
87632
87633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
87634   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87635
87636   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87637   {
87638     try {
87639       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
87640     } catch (std::out_of_range& e) {
87641       {
87642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87643       };
87644     } catch (std::exception& e) {
87645       {
87646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87647       };
87648     } catch (...) {
87649       {
87650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87651       };
87652     }
87653   }
87654 }
87655
87656
87657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
87658   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87659   int arg2 ;
87660   int arg3 ;
87661
87662   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87663   arg2 = (int)jarg2;
87664   arg3 = (int)jarg3;
87665   {
87666     try {
87667       try {
87668         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
87669       }
87670       catch(std::out_of_range &_e) {
87671         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87672         return ;
87673       }
87674       catch(std::invalid_argument &_e) {
87675         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87676         return ;
87677       }
87678
87679     } catch (std::out_of_range& e) {
87680       {
87681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87682       };
87683     } catch (std::exception& e) {
87684       {
87685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87686       };
87687     } catch (...) {
87688       {
87689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87690       };
87691     }
87692   }
87693 }
87694
87695
87696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
87697   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87698   int arg2 ;
87699   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
87700
87701   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87702   arg2 = (int)jarg2;
87703   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
87704   if (!arg3) {
87705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
87706     return ;
87707   }
87708   {
87709     try {
87710       try {
87711         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);
87712       }
87713       catch(std::out_of_range &_e) {
87714         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87715         return ;
87716       }
87717
87718     } catch (std::out_of_range& e) {
87719       {
87720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87721       };
87722     } catch (std::exception& e) {
87723       {
87724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87725       };
87726     } catch (...) {
87727       {
87728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87729       };
87730     }
87731   }
87732 }
87733
87734
87735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
87736   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87737
87738   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87739   {
87740     try {
87741       delete arg1;
87742     } catch (std::out_of_range& e) {
87743       {
87744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87745       };
87746     } catch (std::exception& e) {
87747       {
87748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87749       };
87750     } catch (...) {
87751       {
87752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87753       };
87754     }
87755   }
87756 }
87757
87758
87759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
87760   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87761
87762   arg1 = (std::vector< Dali::Actor > *)jarg1;
87763   {
87764     try {
87765       (arg1)->clear();
87766     } catch (std::out_of_range& e) {
87767       {
87768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87769       };
87770     } catch (std::exception& e) {
87771       {
87772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87773       };
87774     } catch (...) {
87775       {
87776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87777       };
87778     }
87779   }
87780 }
87781
87782
87783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
87784   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87785   Dali::Actor *arg2 = 0 ;
87786
87787   arg1 = (std::vector< Dali::Actor > *)jarg1;
87788   arg2 = (Dali::Actor *)jarg2;
87789   if (!arg2) {
87790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
87791     return ;
87792   }
87793   {
87794     try {
87795       (arg1)->push_back((Dali::Actor const &)*arg2);
87796     } catch (std::out_of_range& e) {
87797       {
87798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87799       };
87800     } catch (std::exception& e) {
87801       {
87802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87803       };
87804     } catch (...) {
87805       {
87806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87807       };
87808     }
87809   }
87810 }
87811
87812
87813 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
87814   unsigned long jresult ;
87815   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87816   std::vector< Dali::Actor >::size_type result;
87817
87818   arg1 = (std::vector< Dali::Actor > *)jarg1;
87819   {
87820     try {
87821       result = ((std::vector< Dali::Actor > const *)arg1)->size();
87822     } catch (std::out_of_range& e) {
87823       {
87824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87825       };
87826     } catch (std::exception& e) {
87827       {
87828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87829       };
87830     } catch (...) {
87831       {
87832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87833       };
87834     }
87835   }
87836   jresult = (unsigned long)result;
87837   return jresult;
87838 }
87839
87840
87841 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
87842   unsigned long jresult ;
87843   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87844   std::vector< Dali::Actor >::size_type result;
87845
87846   arg1 = (std::vector< Dali::Actor > *)jarg1;
87847   {
87848     try {
87849       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
87850     } catch (std::out_of_range& e) {
87851       {
87852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87853       };
87854     } catch (std::exception& e) {
87855       {
87856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87857       };
87858     } catch (...) {
87859       {
87860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87861       };
87862     }
87863   }
87864   jresult = (unsigned long)result;
87865   return jresult;
87866 }
87867
87868
87869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
87870   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87871   std::vector< Dali::Actor >::size_type arg2 ;
87872
87873   arg1 = (std::vector< Dali::Actor > *)jarg1;
87874   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
87875   {
87876     try {
87877       (arg1)->reserve(arg2);
87878     } catch (std::out_of_range& e) {
87879       {
87880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87881       };
87882     } catch (std::exception& e) {
87883       {
87884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87885       };
87886     } catch (...) {
87887       {
87888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87889       };
87890     }
87891   }
87892 }
87893
87894
87895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
87896   void * jresult ;
87897   std::vector< Dali::Actor > *result = 0 ;
87898
87899   {
87900     try {
87901       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
87902     } catch (std::out_of_range& e) {
87903       {
87904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87905       };
87906     } catch (std::exception& e) {
87907       {
87908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87909       };
87910     } catch (...) {
87911       {
87912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87913       };
87914     }
87915   }
87916   jresult = (void *)result;
87917   return jresult;
87918 }
87919
87920
87921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
87922   void * jresult ;
87923   std::vector< Dali::Actor > *arg1 = 0 ;
87924   std::vector< Dali::Actor > *result = 0 ;
87925
87926   arg1 = (std::vector< Dali::Actor > *)jarg1;
87927   if (!arg1) {
87928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
87929     return 0;
87930   }
87931   {
87932     try {
87933       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
87934     } catch (std::out_of_range& e) {
87935       {
87936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87937       };
87938     } catch (std::exception& e) {
87939       {
87940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87941       };
87942     } catch (...) {
87943       {
87944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87945       };
87946     }
87947   }
87948   jresult = (void *)result;
87949   return jresult;
87950 }
87951
87952
87953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
87954   void * jresult ;
87955   int arg1 ;
87956   std::vector< Dali::Actor > *result = 0 ;
87957
87958   arg1 = (int)jarg1;
87959   {
87960     try {
87961       try {
87962         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
87963       }
87964       catch(std::out_of_range &_e) {
87965         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87966         return 0;
87967       }
87968
87969     } catch (std::out_of_range& e) {
87970       {
87971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87972       };
87973     } catch (std::exception& e) {
87974       {
87975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87976       };
87977     } catch (...) {
87978       {
87979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87980       };
87981     }
87982   }
87983   jresult = (void *)result;
87984   return jresult;
87985 }
87986
87987
87988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
87989   void * jresult ;
87990   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87991   int arg2 ;
87992   Dali::Actor result;
87993
87994   arg1 = (std::vector< Dali::Actor > *)jarg1;
87995   arg2 = (int)jarg2;
87996   {
87997     try {
87998       try {
87999         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
88000       }
88001       catch(std::out_of_range &_e) {
88002         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88003         return 0;
88004       }
88005
88006     } catch (std::out_of_range& e) {
88007       {
88008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88009       };
88010     } catch (std::exception& e) {
88011       {
88012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88013       };
88014     } catch (...) {
88015       {
88016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88017       };
88018     }
88019   }
88020   jresult = new Dali::Actor((const Dali::Actor &)result);
88021   return jresult;
88022 }
88023
88024
88025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
88026   void * jresult ;
88027   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88028   int arg2 ;
88029   Dali::Actor *result = 0 ;
88030
88031   arg1 = (std::vector< Dali::Actor > *)jarg1;
88032   arg2 = (int)jarg2;
88033   {
88034     try {
88035       try {
88036         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
88037       }
88038       catch(std::out_of_range &_e) {
88039         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88040         return 0;
88041       }
88042
88043     } catch (std::out_of_range& e) {
88044       {
88045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88046       };
88047     } catch (std::exception& e) {
88048       {
88049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88050       };
88051     } catch (...) {
88052       {
88053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88054       };
88055     }
88056   }
88057   jresult = (void *)result;
88058   return jresult;
88059 }
88060
88061
88062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
88063   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88064   int arg2 ;
88065   Dali::Actor *arg3 = 0 ;
88066
88067   arg1 = (std::vector< Dali::Actor > *)jarg1;
88068   arg2 = (int)jarg2;
88069   arg3 = (Dali::Actor *)jarg3;
88070   if (!arg3) {
88071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
88072     return ;
88073   }
88074   {
88075     try {
88076       try {
88077         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
88078       }
88079       catch(std::out_of_range &_e) {
88080         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88081         return ;
88082       }
88083
88084     } catch (std::out_of_range& e) {
88085       {
88086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88087       };
88088     } catch (std::exception& e) {
88089       {
88090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88091       };
88092     } catch (...) {
88093       {
88094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88095       };
88096     }
88097   }
88098 }
88099
88100
88101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
88102   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88103   std::vector< Dali::Actor > *arg2 = 0 ;
88104
88105   arg1 = (std::vector< Dali::Actor > *)jarg1;
88106   arg2 = (std::vector< Dali::Actor > *)jarg2;
88107   if (!arg2) {
88108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
88109     return ;
88110   }
88111   {
88112     try {
88113       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
88114     } catch (std::out_of_range& e) {
88115       {
88116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88117       };
88118     } catch (std::exception& e) {
88119       {
88120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88121       };
88122     } catch (...) {
88123       {
88124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88125       };
88126     }
88127   }
88128 }
88129
88130
88131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
88132   void * jresult ;
88133   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88134   int arg2 ;
88135   int arg3 ;
88136   std::vector< Dali::Actor > *result = 0 ;
88137
88138   arg1 = (std::vector< Dali::Actor > *)jarg1;
88139   arg2 = (int)jarg2;
88140   arg3 = (int)jarg3;
88141   {
88142     try {
88143       try {
88144         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
88145       }
88146       catch(std::out_of_range &_e) {
88147         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88148         return 0;
88149       }
88150       catch(std::invalid_argument &_e) {
88151         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88152         return 0;
88153       }
88154
88155     } catch (std::out_of_range& e) {
88156       {
88157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88158       };
88159     } catch (std::exception& e) {
88160       {
88161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88162       };
88163     } catch (...) {
88164       {
88165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88166       };
88167     }
88168   }
88169   jresult = (void *)result;
88170   return jresult;
88171 }
88172
88173
88174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
88175   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88176   int arg2 ;
88177   Dali::Actor *arg3 = 0 ;
88178
88179   arg1 = (std::vector< Dali::Actor > *)jarg1;
88180   arg2 = (int)jarg2;
88181   arg3 = (Dali::Actor *)jarg3;
88182   if (!arg3) {
88183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
88184     return ;
88185   }
88186   {
88187     try {
88188       try {
88189         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
88190       }
88191       catch(std::out_of_range &_e) {
88192         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88193         return ;
88194       }
88195
88196     } catch (std::out_of_range& e) {
88197       {
88198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88199       };
88200     } catch (std::exception& e) {
88201       {
88202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88203       };
88204     } catch (...) {
88205       {
88206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88207       };
88208     }
88209   }
88210 }
88211
88212
88213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
88214   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88215   int arg2 ;
88216   std::vector< Dali::Actor > *arg3 = 0 ;
88217
88218   arg1 = (std::vector< Dali::Actor > *)jarg1;
88219   arg2 = (int)jarg2;
88220   arg3 = (std::vector< Dali::Actor > *)jarg3;
88221   if (!arg3) {
88222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
88223     return ;
88224   }
88225   {
88226     try {
88227       try {
88228         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
88229       }
88230       catch(std::out_of_range &_e) {
88231         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88232         return ;
88233       }
88234
88235     } catch (std::out_of_range& e) {
88236       {
88237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88238       };
88239     } catch (std::exception& e) {
88240       {
88241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88242       };
88243     } catch (...) {
88244       {
88245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88246       };
88247     }
88248   }
88249 }
88250
88251
88252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
88253   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88254   int arg2 ;
88255
88256   arg1 = (std::vector< Dali::Actor > *)jarg1;
88257   arg2 = (int)jarg2;
88258   {
88259     try {
88260       try {
88261         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
88262       }
88263       catch(std::out_of_range &_e) {
88264         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88265         return ;
88266       }
88267
88268     } catch (std::out_of_range& e) {
88269       {
88270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88271       };
88272     } catch (std::exception& e) {
88273       {
88274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88275       };
88276     } catch (...) {
88277       {
88278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88279       };
88280     }
88281   }
88282 }
88283
88284
88285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
88286   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88287   int arg2 ;
88288   int arg3 ;
88289
88290   arg1 = (std::vector< Dali::Actor > *)jarg1;
88291   arg2 = (int)jarg2;
88292   arg3 = (int)jarg3;
88293   {
88294     try {
88295       try {
88296         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
88297       }
88298       catch(std::out_of_range &_e) {
88299         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88300         return ;
88301       }
88302       catch(std::invalid_argument &_e) {
88303         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88304         return ;
88305       }
88306
88307     } catch (std::out_of_range& e) {
88308       {
88309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88310       };
88311     } catch (std::exception& e) {
88312       {
88313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88314       };
88315     } catch (...) {
88316       {
88317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88318       };
88319     }
88320   }
88321 }
88322
88323
88324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
88325   void * jresult ;
88326   Dali::Actor *arg1 = 0 ;
88327   int arg2 ;
88328   std::vector< Dali::Actor > *result = 0 ;
88329
88330   arg1 = (Dali::Actor *)jarg1;
88331   if (!arg1) {
88332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
88333     return 0;
88334   }
88335   arg2 = (int)jarg2;
88336   {
88337     try {
88338       try {
88339         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
88340       }
88341       catch(std::out_of_range &_e) {
88342         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88343         return 0;
88344       }
88345
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 = (void *)result;
88361   return jresult;
88362 }
88363
88364
88365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
88366   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88367
88368   arg1 = (std::vector< Dali::Actor > *)jarg1;
88369   {
88370     try {
88371       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
88372     } catch (std::out_of_range& e) {
88373       {
88374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88375       };
88376     } catch (std::exception& e) {
88377       {
88378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88379       };
88380     } catch (...) {
88381       {
88382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88383       };
88384     }
88385   }
88386 }
88387
88388
88389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
88390   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88391   int arg2 ;
88392   int arg3 ;
88393
88394   arg1 = (std::vector< Dali::Actor > *)jarg1;
88395   arg2 = (int)jarg2;
88396   arg3 = (int)jarg3;
88397   {
88398     try {
88399       try {
88400         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
88401       }
88402       catch(std::out_of_range &_e) {
88403         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88404         return ;
88405       }
88406       catch(std::invalid_argument &_e) {
88407         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88408         return ;
88409       }
88410
88411     } catch (std::out_of_range& e) {
88412       {
88413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88414       };
88415     } catch (std::exception& e) {
88416       {
88417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88418       };
88419     } catch (...) {
88420       {
88421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88422       };
88423     }
88424   }
88425 }
88426
88427
88428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
88429   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88430   int arg2 ;
88431   std::vector< Dali::Actor > *arg3 = 0 ;
88432
88433   arg1 = (std::vector< Dali::Actor > *)jarg1;
88434   arg2 = (int)jarg2;
88435   arg3 = (std::vector< Dali::Actor > *)jarg3;
88436   if (!arg3) {
88437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
88438     return ;
88439   }
88440   {
88441     try {
88442       try {
88443         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
88444       }
88445       catch(std::out_of_range &_e) {
88446         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88447         return ;
88448       }
88449
88450     } catch (std::out_of_range& e) {
88451       {
88452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88453       };
88454     } catch (std::exception& e) {
88455       {
88456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88457       };
88458     } catch (...) {
88459       {
88460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88461       };
88462     }
88463   }
88464 }
88465
88466
88467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
88468   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88469
88470   arg1 = (std::vector< Dali::Actor > *)jarg1;
88471   {
88472     try {
88473       delete arg1;
88474     } catch (std::out_of_range& e) {
88475       {
88476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88477       };
88478     } catch (std::exception& e) {
88479       {
88480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88481       };
88482     } catch (...) {
88483       {
88484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88485       };
88486     }
88487   }
88488 }
88489
88490
88491 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
88492   unsigned int jresult ;
88493   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88494   bool result;
88495
88496   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88497   {
88498     try {
88499       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
88500     } catch (std::out_of_range& e) {
88501       {
88502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88503       };
88504     } catch (std::exception& e) {
88505       {
88506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88507       };
88508     } catch (...) {
88509       {
88510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88511       };
88512     }
88513   }
88514   jresult = result;
88515   return jresult;
88516 }
88517
88518
88519 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
88520   unsigned long jresult ;
88521   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88522   std::size_t result;
88523
88524   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88525   {
88526     try {
88527       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
88528     } catch (std::out_of_range& e) {
88529       {
88530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88531       };
88532     } catch (std::exception& e) {
88533       {
88534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88535       };
88536     } catch (...) {
88537       {
88538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88539       };
88540     }
88541   }
88542   jresult = (unsigned long)result;
88543   return jresult;
88544 }
88545
88546
88547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
88548   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88549   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
88550
88551   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88552   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
88553   {
88554     try {
88555       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
88556     } catch (std::out_of_range& e) {
88557       {
88558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88559       };
88560     } catch (std::exception& e) {
88561       {
88562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88563       };
88564     } catch (...) {
88565       {
88566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88567       };
88568     }
88569   }
88570 }
88571
88572
88573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
88574   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88575   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
88576
88577   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88578   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
88579   {
88580     try {
88581       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
88582     } catch (std::out_of_range& e) {
88583       {
88584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88585       };
88586     } catch (std::exception& e) {
88587       {
88588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88589       };
88590     } catch (...) {
88591       {
88592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88593       };
88594     }
88595   }
88596 }
88597
88598
88599 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
88600   unsigned int jresult ;
88601   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88602   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
88603   bool result;
88604
88605   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88606   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
88607   if (!arg2) {
88608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
88609     return 0;
88610   }
88611   {
88612     try {
88613       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
88614     } catch (std::out_of_range& e) {
88615       {
88616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88617       };
88618     } catch (std::exception& e) {
88619       {
88620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88621       };
88622     } catch (...) {
88623       {
88624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88625       };
88626     }
88627   }
88628   jresult = result;
88629   return jresult;
88630 }
88631
88632
88633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
88634   void * jresult ;
88635   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
88636
88637   {
88638     try {
88639       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
88640     } catch (std::out_of_range& e) {
88641       {
88642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88643       };
88644     } catch (std::exception& e) {
88645       {
88646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88647       };
88648     } catch (...) {
88649       {
88650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88651       };
88652     }
88653   }
88654   jresult = (void *)result;
88655   return jresult;
88656 }
88657
88658
88659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
88660   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88661
88662   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88663   {
88664     try {
88665       delete arg1;
88666     } catch (std::out_of_range& e) {
88667       {
88668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88669       };
88670     } catch (std::exception& e) {
88671       {
88672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88673       };
88674     } catch (...) {
88675       {
88676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88677       };
88678     }
88679   }
88680 }
88681
88682
88683 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
88684   unsigned int jresult ;
88685   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88686   bool result;
88687
88688   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88689   {
88690     try {
88691       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);
88692     } catch (std::out_of_range& e) {
88693       {
88694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88695       };
88696     } catch (std::exception& e) {
88697       {
88698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88699       };
88700     } catch (...) {
88701       {
88702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88703       };
88704     }
88705   }
88706   jresult = result;
88707   return jresult;
88708 }
88709
88710
88711 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
88712   unsigned long jresult ;
88713   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88714   std::size_t result;
88715
88716   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88717   {
88718     try {
88719       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);
88720     } catch (std::out_of_range& e) {
88721       {
88722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88723       };
88724     } catch (std::exception& e) {
88725       {
88726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88727       };
88728     } catch (...) {
88729       {
88730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88731       };
88732     }
88733   }
88734   jresult = (unsigned long)result;
88735   return jresult;
88736 }
88737
88738
88739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
88740   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88741   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
88742
88743   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88744   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
88745   {
88746     try {
88747       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
88748     } catch (std::out_of_range& e) {
88749       {
88750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88751       };
88752     } catch (std::exception& e) {
88753       {
88754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88755       };
88756     } catch (...) {
88757       {
88758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88759       };
88760     }
88761   }
88762 }
88763
88764
88765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
88766   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88767   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
88768
88769   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88770   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
88771   {
88772     try {
88773       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
88774     } catch (std::out_of_range& e) {
88775       {
88776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88777       };
88778     } catch (std::exception& e) {
88779       {
88780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88781       };
88782     } catch (...) {
88783       {
88784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88785       };
88786     }
88787   }
88788 }
88789
88790
88791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
88792   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88793   Dali::Actor arg2 ;
88794   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
88795   Dali::Actor *argp2 ;
88796
88797   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88798   argp2 = (Dali::Actor *)jarg2;
88799   if (!argp2) {
88800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88801     return ;
88802   }
88803   arg2 = *argp2;
88804   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
88805   {
88806     try {
88807       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
88808     } catch (std::out_of_range& e) {
88809       {
88810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88811       };
88812     } catch (std::exception& e) {
88813       {
88814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88815       };
88816     } catch (...) {
88817       {
88818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88819       };
88820     }
88821   }
88822 }
88823
88824
88825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
88826   void * jresult ;
88827   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
88828
88829   {
88830     try {
88831       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
88832     } catch (std::out_of_range& e) {
88833       {
88834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88835       };
88836     } catch (std::exception& e) {
88837       {
88838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88839       };
88840     } catch (...) {
88841       {
88842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88843       };
88844     }
88845   }
88846   jresult = (void *)result;
88847   return jresult;
88848 }
88849
88850
88851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
88852   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88853
88854   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88855   {
88856     try {
88857       delete arg1;
88858     } catch (std::out_of_range& e) {
88859       {
88860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88861       };
88862     } catch (std::exception& e) {
88863       {
88864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88865       };
88866     } catch (...) {
88867       {
88868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88869       };
88870     }
88871   }
88872 }
88873
88874
88875 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
88876   unsigned int jresult ;
88877   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88878   bool result;
88879
88880   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88881   {
88882     try {
88883       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
88884     } catch (std::out_of_range& e) {
88885       {
88886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88887       };
88888     } catch (std::exception& e) {
88889       {
88890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88891       };
88892     } catch (...) {
88893       {
88894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88895       };
88896     }
88897   }
88898   jresult = result;
88899   return jresult;
88900 }
88901
88902
88903 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
88904   unsigned long jresult ;
88905   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88906   std::size_t result;
88907
88908   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88909   {
88910     try {
88911       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
88912     } catch (std::out_of_range& e) {
88913       {
88914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88915       };
88916     } catch (std::exception& e) {
88917       {
88918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88919       };
88920     } catch (...) {
88921       {
88922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88923       };
88924     }
88925   }
88926   jresult = (unsigned long)result;
88927   return jresult;
88928 }
88929
88930
88931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
88932   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88933   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
88934
88935   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88936   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
88937   {
88938     try {
88939       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
88940     } catch (std::out_of_range& e) {
88941       {
88942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88943       };
88944     } catch (std::exception& e) {
88945       {
88946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88947       };
88948     } catch (...) {
88949       {
88950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88951       };
88952     }
88953   }
88954 }
88955
88956
88957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
88958   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88959   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
88960
88961   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88962   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
88963   {
88964     try {
88965       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
88966     } catch (std::out_of_range& e) {
88967       {
88968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88969       };
88970     } catch (std::exception& e) {
88971       {
88972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88973       };
88974     } catch (...) {
88975       {
88976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88977       };
88978     }
88979   }
88980 }
88981
88982
88983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
88984   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88985   Dali::Actor arg2 ;
88986   Dali::Actor arg3 ;
88987   Dali::Actor *argp2 ;
88988   Dali::Actor *argp3 ;
88989
88990   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88991   argp2 = (Dali::Actor *)jarg2;
88992   if (!argp2) {
88993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88994     return ;
88995   }
88996   arg2 = *argp2;
88997   argp3 = (Dali::Actor *)jarg3;
88998   if (!argp3) {
88999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89000     return ;
89001   }
89002   arg3 = *argp3;
89003   {
89004     try {
89005       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
89006     } catch (std::out_of_range& e) {
89007       {
89008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89009       };
89010     } catch (std::exception& e) {
89011       {
89012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89013       };
89014     } catch (...) {
89015       {
89016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89017       };
89018     }
89019   }
89020 }
89021
89022
89023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
89024   void * jresult ;
89025   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
89026
89027   {
89028     try {
89029       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
89030     } catch (std::out_of_range& e) {
89031       {
89032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89033       };
89034     } catch (std::exception& e) {
89035       {
89036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89037       };
89038     } catch (...) {
89039       {
89040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89041       };
89042     }
89043   }
89044   jresult = (void *)result;
89045   return jresult;
89046 }
89047
89048
89049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
89050   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89051
89052   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89053   {
89054     try {
89055       delete arg1;
89056     } catch (std::out_of_range& e) {
89057       {
89058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89059       };
89060     } catch (std::exception& e) {
89061       {
89062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89063       };
89064     } catch (...) {
89065       {
89066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89067       };
89068     }
89069   }
89070 }
89071
89072
89073 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
89074   unsigned int jresult ;
89075   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89076   bool result;
89077
89078   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89079   {
89080     try {
89081       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
89082     } catch (std::out_of_range& e) {
89083       {
89084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89085       };
89086     } catch (std::exception& e) {
89087       {
89088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89089       };
89090     } catch (...) {
89091       {
89092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89093       };
89094     }
89095   }
89096   jresult = result;
89097   return jresult;
89098 }
89099
89100
89101 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
89102   unsigned long jresult ;
89103   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89104   std::size_t result;
89105
89106   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89107   {
89108     try {
89109       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
89110     } catch (std::out_of_range& e) {
89111       {
89112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89113       };
89114     } catch (std::exception& e) {
89115       {
89116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89117       };
89118     } catch (...) {
89119       {
89120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89121       };
89122     }
89123   }
89124   jresult = (unsigned long)result;
89125   return jresult;
89126 }
89127
89128
89129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
89130   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89131   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
89132
89133   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89134   arg2 = (void (*)(Dali::Actor,bool))jarg2;
89135   {
89136     try {
89137       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
89138     } catch (std::out_of_range& e) {
89139       {
89140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89141       };
89142     } catch (std::exception& e) {
89143       {
89144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89145       };
89146     } catch (...) {
89147       {
89148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89149       };
89150     }
89151   }
89152 }
89153
89154
89155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
89156   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89157   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
89158
89159   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89160   arg2 = (void (*)(Dali::Actor,bool))jarg2;
89161   {
89162     try {
89163       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
89164     } catch (std::out_of_range& e) {
89165       {
89166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89167       };
89168     } catch (std::exception& e) {
89169       {
89170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89171       };
89172     } catch (...) {
89173       {
89174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89175       };
89176     }
89177   }
89178 }
89179
89180
89181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
89182   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89183   Dali::Actor arg2 ;
89184   bool arg3 ;
89185   Dali::Actor *argp2 ;
89186
89187   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89188   argp2 = (Dali::Actor *)jarg2;
89189   if (!argp2) {
89190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89191     return ;
89192   }
89193   arg2 = *argp2;
89194   arg3 = jarg3 ? true : false;
89195   {
89196     try {
89197       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
89198     } catch (std::out_of_range& e) {
89199       {
89200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89201       };
89202     } catch (std::exception& e) {
89203       {
89204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89205       };
89206     } catch (...) {
89207       {
89208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89209       };
89210     }
89211   }
89212 }
89213
89214
89215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
89216   void * jresult ;
89217   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
89218
89219   {
89220     try {
89221       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
89222     } catch (std::out_of_range& e) {
89223       {
89224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89225       };
89226     } catch (std::exception& e) {
89227       {
89228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89229       };
89230     } catch (...) {
89231       {
89232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89233       };
89234     }
89235   }
89236   jresult = (void *)result;
89237   return jresult;
89238 }
89239
89240
89241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
89242   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89243
89244   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89245   {
89246     try {
89247       delete arg1;
89248     } catch (std::out_of_range& e) {
89249       {
89250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89251       };
89252     } catch (std::exception& e) {
89253       {
89254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89255       };
89256     } catch (...) {
89257       {
89258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89259       };
89260     }
89261   }
89262 }
89263
89264
89265 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
89266   unsigned int jresult ;
89267   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89268   bool result;
89269
89270   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89271   {
89272     try {
89273       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);
89274     } catch (std::out_of_range& e) {
89275       {
89276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89277       };
89278     } catch (std::exception& e) {
89279       {
89280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89281       };
89282     } catch (...) {
89283       {
89284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89285       };
89286     }
89287   }
89288   jresult = result;
89289   return jresult;
89290 }
89291
89292
89293 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
89294   unsigned long jresult ;
89295   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89296   std::size_t result;
89297
89298   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89299   {
89300     try {
89301       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);
89302     } catch (std::out_of_range& e) {
89303       {
89304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89305       };
89306     } catch (std::exception& e) {
89307       {
89308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89309       };
89310     } catch (...) {
89311       {
89312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89313       };
89314     }
89315   }
89316   jresult = (unsigned long)result;
89317   return jresult;
89318 }
89319
89320
89321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
89322   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89323   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
89324
89325   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89326   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
89327   {
89328     try {
89329       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
89330     } catch (std::out_of_range& e) {
89331       {
89332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89333       };
89334     } catch (std::exception& e) {
89335       {
89336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89337       };
89338     } catch (...) {
89339       {
89340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89341       };
89342     }
89343   }
89344 }
89345
89346
89347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
89348   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89349   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
89350
89351   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89352   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
89353   {
89354     try {
89355       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
89356     } catch (std::out_of_range& e) {
89357       {
89358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89359       };
89360     } catch (std::exception& e) {
89361       {
89362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89363       };
89364     } catch (...) {
89365       {
89366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89367       };
89368     }
89369   }
89370 }
89371
89372
89373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
89374   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89375   Dali::Toolkit::StyleManager arg2 ;
89376   Dali::StyleChange::Type arg3 ;
89377   Dali::Toolkit::StyleManager *argp2 ;
89378
89379   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89380   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
89381   if (!argp2) {
89382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
89383     return ;
89384   }
89385   arg2 = *argp2;
89386   arg3 = (Dali::StyleChange::Type)jarg3;
89387   {
89388     try {
89389       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
89390     } catch (std::out_of_range& e) {
89391       {
89392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89393       };
89394     } catch (std::exception& e) {
89395       {
89396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89397       };
89398     } catch (...) {
89399       {
89400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89401       };
89402     }
89403   }
89404 }
89405
89406
89407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
89408   void * jresult ;
89409   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
89410
89411   {
89412     try {
89413       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
89414     } catch (std::out_of_range& e) {
89415       {
89416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89417       };
89418     } catch (std::exception& e) {
89419       {
89420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89421       };
89422     } catch (...) {
89423       {
89424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89425       };
89426     }
89427   }
89428   jresult = (void *)result;
89429   return jresult;
89430 }
89431
89432
89433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
89434   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89435
89436   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89437   {
89438     try {
89439       delete arg1;
89440     } catch (std::out_of_range& e) {
89441       {
89442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89443       };
89444     } catch (std::exception& e) {
89445       {
89446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89447       };
89448     } catch (...) {
89449       {
89450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89451       };
89452     }
89453   }
89454 }
89455
89456
89457 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
89458   unsigned int jresult ;
89459   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89460   bool result;
89461
89462   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89463   {
89464     try {
89465       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
89466     } catch (std::out_of_range& e) {
89467       {
89468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89469       };
89470     } catch (std::exception& e) {
89471       {
89472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89473       };
89474     } catch (...) {
89475       {
89476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89477       };
89478     }
89479   }
89480   jresult = result;
89481   return jresult;
89482 }
89483
89484
89485 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
89486   unsigned long jresult ;
89487   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89488   std::size_t result;
89489
89490   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89491   {
89492     try {
89493       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
89494     } catch (std::out_of_range& e) {
89495       {
89496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89497       };
89498     } catch (std::exception& e) {
89499       {
89500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89501       };
89502     } catch (...) {
89503       {
89504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89505       };
89506     }
89507   }
89508   jresult = (unsigned long)result;
89509   return jresult;
89510 }
89511
89512
89513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
89514   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89515   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
89516
89517   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89518   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
89519   {
89520     try {
89521       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
89522     } catch (std::out_of_range& e) {
89523       {
89524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89525       };
89526     } catch (std::exception& e) {
89527       {
89528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89529       };
89530     } catch (...) {
89531       {
89532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89533       };
89534     }
89535   }
89536 }
89537
89538
89539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
89540   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89541   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
89542
89543   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89544   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
89545   {
89546     try {
89547       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
89548     } catch (std::out_of_range& e) {
89549       {
89550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89551       };
89552     } catch (std::exception& e) {
89553       {
89554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89555       };
89556     } catch (...) {
89557       {
89558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89559       };
89560     }
89561   }
89562 }
89563
89564
89565 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
89566   unsigned int jresult ;
89567   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89568   Dali::Toolkit::Button arg2 ;
89569   Dali::Toolkit::Button *argp2 ;
89570   bool result;
89571
89572   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89573   argp2 = (Dali::Toolkit::Button *)jarg2;
89574   if (!argp2) {
89575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
89576     return 0;
89577   }
89578   arg2 = *argp2;
89579   {
89580     try {
89581       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
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 void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
89602   void * jresult ;
89603   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
89604
89605   {
89606     try {
89607       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
89608     } catch (std::out_of_range& e) {
89609       {
89610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89611       };
89612     } catch (std::exception& e) {
89613       {
89614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89615       };
89616     } catch (...) {
89617       {
89618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89619       };
89620     }
89621   }
89622   jresult = (void *)result;
89623   return jresult;
89624 }
89625
89626
89627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
89628   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89629
89630   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89631   {
89632     try {
89633       delete arg1;
89634     } catch (std::out_of_range& e) {
89635       {
89636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89637       };
89638     } catch (std::exception& e) {
89639       {
89640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89641       };
89642     } catch (...) {
89643       {
89644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89645       };
89646     }
89647   }
89648 }
89649
89650
89651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
89652   unsigned int jresult ;
89653   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89654   bool result;
89655
89656   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89657   {
89658     try {
89659       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
89660     } catch (std::out_of_range& e) {
89661       {
89662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89663       };
89664     } catch (std::exception& e) {
89665       {
89666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89667       };
89668     } catch (...) {
89669       {
89670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89671       };
89672     }
89673   }
89674   jresult = result;
89675   return jresult;
89676 }
89677
89678
89679 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
89680   unsigned long jresult ;
89681   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89682   std::size_t result;
89683
89684   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89685   {
89686     try {
89687       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
89688     } catch (std::out_of_range& e) {
89689       {
89690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89691       };
89692     } catch (std::exception& e) {
89693       {
89694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89695       };
89696     } catch (...) {
89697       {
89698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89699       };
89700     }
89701   }
89702   jresult = (unsigned long)result;
89703   return jresult;
89704 }
89705
89706
89707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
89708   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89709   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
89710
89711   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89712   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
89713   {
89714     try {
89715       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
89716     } catch (std::out_of_range& e) {
89717       {
89718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89719       };
89720     } catch (std::exception& e) {
89721       {
89722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89723       };
89724     } catch (...) {
89725       {
89726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89727       };
89728     }
89729   }
89730 }
89731
89732
89733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
89734   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89735   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
89736
89737   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89738   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
89739   {
89740     try {
89741       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
89742     } catch (std::out_of_range& e) {
89743       {
89744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89745       };
89746     } catch (std::exception& e) {
89747       {
89748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89749       };
89750     } catch (...) {
89751       {
89752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89753       };
89754     }
89755   }
89756 }
89757
89758
89759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
89760   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89761   Dali::Toolkit::GaussianBlurView arg2 ;
89762   Dali::Toolkit::GaussianBlurView *argp2 ;
89763
89764   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89765   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
89766   if (!argp2) {
89767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
89768     return ;
89769   }
89770   arg2 = *argp2;
89771   {
89772     try {
89773       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
89774     } catch (std::out_of_range& e) {
89775       {
89776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89777       };
89778     } catch (std::exception& e) {
89779       {
89780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89781       };
89782     } catch (...) {
89783       {
89784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89785       };
89786     }
89787   }
89788 }
89789
89790
89791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
89792   void * jresult ;
89793   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
89794
89795   {
89796     try {
89797       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
89798     } catch (std::out_of_range& e) {
89799       {
89800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89801       };
89802     } catch (std::exception& e) {
89803       {
89804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89805       };
89806     } catch (...) {
89807       {
89808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89809       };
89810     }
89811   }
89812   jresult = (void *)result;
89813   return jresult;
89814 }
89815
89816
89817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
89818   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89819
89820   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89821   {
89822     try {
89823       delete arg1;
89824     } catch (std::out_of_range& e) {
89825       {
89826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89827       };
89828     } catch (std::exception& e) {
89829       {
89830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89831       };
89832     } catch (...) {
89833       {
89834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89835       };
89836     }
89837   }
89838 }
89839
89840
89841 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
89842   unsigned int jresult ;
89843   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89844   bool result;
89845
89846   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89847   {
89848     try {
89849       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);
89850     } catch (std::out_of_range& e) {
89851       {
89852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89853       };
89854     } catch (std::exception& e) {
89855       {
89856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89857       };
89858     } catch (...) {
89859       {
89860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89861       };
89862     }
89863   }
89864   jresult = result;
89865   return jresult;
89866 }
89867
89868
89869 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
89870   unsigned long jresult ;
89871   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89872   std::size_t result;
89873
89874   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89875   {
89876     try {
89877       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);
89878     } catch (std::out_of_range& e) {
89879       {
89880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89881       };
89882     } catch (std::exception& e) {
89883       {
89884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89885       };
89886     } catch (...) {
89887       {
89888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89889       };
89890     }
89891   }
89892   jresult = (unsigned long)result;
89893   return jresult;
89894 }
89895
89896
89897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
89898   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89899   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
89900
89901   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89902   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
89903   {
89904     try {
89905       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
89906     } catch (std::out_of_range& e) {
89907       {
89908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89909       };
89910     } catch (std::exception& e) {
89911       {
89912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89913       };
89914     } catch (...) {
89915       {
89916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89917       };
89918     }
89919   }
89920 }
89921
89922
89923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
89924   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89925   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
89926
89927   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89928   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
89929   {
89930     try {
89931       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
89932     } catch (std::out_of_range& e) {
89933       {
89934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89935       };
89936     } catch (std::exception& e) {
89937       {
89938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89939       };
89940     } catch (...) {
89941       {
89942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89943       };
89944     }
89945   }
89946 }
89947
89948
89949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
89950   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89951   Dali::Toolkit::PageTurnView arg2 ;
89952   unsigned int arg3 ;
89953   bool arg4 ;
89954   Dali::Toolkit::PageTurnView *argp2 ;
89955
89956   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89957   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
89958   if (!argp2) {
89959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
89960     return ;
89961   }
89962   arg2 = *argp2;
89963   arg3 = (unsigned int)jarg3;
89964   arg4 = jarg4 ? true : false;
89965   {
89966     try {
89967       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
89968     } catch (std::out_of_range& e) {
89969       {
89970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89971       };
89972     } catch (std::exception& e) {
89973       {
89974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89975       };
89976     } catch (...) {
89977       {
89978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89979       };
89980     }
89981   }
89982 }
89983
89984
89985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
89986   void * jresult ;
89987   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
89988
89989   {
89990     try {
89991       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
89992     } catch (std::out_of_range& e) {
89993       {
89994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89995       };
89996     } catch (std::exception& e) {
89997       {
89998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89999       };
90000     } catch (...) {
90001       {
90002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90003       };
90004     }
90005   }
90006   jresult = (void *)result;
90007   return jresult;
90008 }
90009
90010
90011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
90012   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90013
90014   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90015   {
90016     try {
90017       delete arg1;
90018     } catch (std::out_of_range& e) {
90019       {
90020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90021       };
90022     } catch (std::exception& e) {
90023       {
90024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90025       };
90026     } catch (...) {
90027       {
90028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90029       };
90030     }
90031   }
90032 }
90033
90034
90035 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
90036   unsigned int jresult ;
90037   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90038   bool result;
90039
90040   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90041   {
90042     try {
90043       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
90044     } catch (std::out_of_range& e) {
90045       {
90046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90047       };
90048     } catch (std::exception& e) {
90049       {
90050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90051       };
90052     } catch (...) {
90053       {
90054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90055       };
90056     }
90057   }
90058   jresult = result;
90059   return jresult;
90060 }
90061
90062
90063 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
90064   unsigned long jresult ;
90065   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90066   std::size_t result;
90067
90068   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90069   {
90070     try {
90071       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
90072     } catch (std::out_of_range& e) {
90073       {
90074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90075       };
90076     } catch (std::exception& e) {
90077       {
90078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90079       };
90080     } catch (...) {
90081       {
90082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90083       };
90084     }
90085   }
90086   jresult = (unsigned long)result;
90087   return jresult;
90088 }
90089
90090
90091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
90092   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90093   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
90094
90095   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90096   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
90097   {
90098     try {
90099       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
90100     } catch (std::out_of_range& e) {
90101       {
90102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90103       };
90104     } catch (std::exception& e) {
90105       {
90106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90107       };
90108     } catch (...) {
90109       {
90110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90111       };
90112     }
90113   }
90114 }
90115
90116
90117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
90118   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90119   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
90120
90121   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90122   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
90123   {
90124     try {
90125       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
90126     } catch (std::out_of_range& e) {
90127       {
90128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90129       };
90130     } catch (std::exception& e) {
90131       {
90132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90133       };
90134     } catch (...) {
90135       {
90136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90137       };
90138     }
90139   }
90140 }
90141
90142
90143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
90144   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90145   Dali::Toolkit::PageTurnView arg2 ;
90146   Dali::Toolkit::PageTurnView *argp2 ;
90147
90148   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90149   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
90150   if (!argp2) {
90151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
90152     return ;
90153   }
90154   arg2 = *argp2;
90155   {
90156     try {
90157       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
90158     } catch (std::out_of_range& e) {
90159       {
90160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90161       };
90162     } catch (std::exception& e) {
90163       {
90164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90165       };
90166     } catch (...) {
90167       {
90168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90169       };
90170     }
90171   }
90172 }
90173
90174
90175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
90176   void * jresult ;
90177   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
90178
90179   {
90180     try {
90181       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
90182     } catch (std::out_of_range& e) {
90183       {
90184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90185       };
90186     } catch (std::exception& e) {
90187       {
90188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90189       };
90190     } catch (...) {
90191       {
90192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90193       };
90194     }
90195   }
90196   jresult = (void *)result;
90197   return jresult;
90198 }
90199
90200
90201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
90202   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90203
90204   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90205   {
90206     try {
90207       delete arg1;
90208     } catch (std::out_of_range& e) {
90209       {
90210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90211       };
90212     } catch (std::exception& e) {
90213       {
90214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90215       };
90216     } catch (...) {
90217       {
90218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90219       };
90220     }
90221   }
90222 }
90223
90224
90225 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
90226   unsigned int jresult ;
90227   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
90228   bool result;
90229
90230   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
90231   {
90232     try {
90233       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);
90234     } catch (std::out_of_range& e) {
90235       {
90236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90237       };
90238     } catch (std::exception& e) {
90239       {
90240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90241       };
90242     } catch (...) {
90243       {
90244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90245       };
90246     }
90247   }
90248   jresult = result;
90249   return jresult;
90250 }
90251
90252
90253 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
90254   unsigned long jresult ;
90255   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
90256   std::size_t result;
90257
90258   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
90259   {
90260     try {
90261       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);
90262     } catch (std::out_of_range& e) {
90263       {
90264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90265       };
90266     } catch (std::exception& e) {
90267       {
90268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90269       };
90270     } catch (...) {
90271       {
90272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90273       };
90274     }
90275   }
90276   jresult = (unsigned long)result;
90277   return jresult;
90278 }
90279
90280
90281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
90282   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
90283   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
90284
90285   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
90286   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
90287   {
90288     try {
90289       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
90290     } catch (std::out_of_range& e) {
90291       {
90292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90293       };
90294     } catch (std::exception& e) {
90295       {
90296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90297       };
90298     } catch (...) {
90299       {
90300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90301       };
90302     }
90303   }
90304 }
90305
90306
90307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90308   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
90309   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
90310
90311   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
90312   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
90313   {
90314     try {
90315       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
90316     } catch (std::out_of_range& e) {
90317       {
90318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90319       };
90320     } catch (std::exception& e) {
90321       {
90322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90323       };
90324     } catch (...) {
90325       {
90326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90327       };
90328     }
90329   }
90330 }
90331
90332
90333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
90334   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
90335   Dali::Toolkit::ProgressBar arg2 ;
90336   float arg3 ;
90337   float arg4 ;
90338   Dali::Toolkit::ProgressBar *argp2 ;
90339
90340   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
90341   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
90342   if (!argp2) {
90343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
90344     return ;
90345   }
90346   arg2 = *argp2;
90347   arg3 = (float)jarg3;
90348   arg4 = (float)jarg4;
90349   {
90350     try {
90351       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
90352     } catch (std::out_of_range& e) {
90353       {
90354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90355       };
90356     } catch (std::exception& e) {
90357       {
90358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90359       };
90360     } catch (...) {
90361       {
90362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90363       };
90364     }
90365   }
90366 }
90367
90368
90369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
90370   void * jresult ;
90371   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
90372
90373   {
90374     try {
90375       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
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 = (void *)result;
90391   return jresult;
90392 }
90393
90394
90395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
90396   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
90397
90398   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
90399   {
90400     try {
90401       delete arg1;
90402     } catch (std::out_of_range& e) {
90403       {
90404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90405       };
90406     } catch (std::exception& e) {
90407       {
90408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90409       };
90410     } catch (...) {
90411       {
90412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90413       };
90414     }
90415   }
90416 }
90417
90418
90419 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
90420   unsigned int jresult ;
90421   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90422   bool result;
90423
90424   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90425   {
90426     try {
90427       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);
90428     } catch (std::out_of_range& e) {
90429       {
90430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90431       };
90432     } catch (std::exception& e) {
90433       {
90434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90435       };
90436     } catch (...) {
90437       {
90438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90439       };
90440     }
90441   }
90442   jresult = result;
90443   return jresult;
90444 }
90445
90446
90447 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
90448   unsigned long jresult ;
90449   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90450   std::size_t result;
90451
90452   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90453   {
90454     try {
90455       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);
90456     } catch (std::out_of_range& e) {
90457       {
90458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90459       };
90460     } catch (std::exception& e) {
90461       {
90462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90463       };
90464     } catch (...) {
90465       {
90466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90467       };
90468     }
90469   }
90470   jresult = (unsigned long)result;
90471   return jresult;
90472 }
90473
90474
90475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
90476   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90477   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
90478
90479   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90480   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
90481   {
90482     try {
90483       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
90484     } catch (std::out_of_range& e) {
90485       {
90486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90487       };
90488     } catch (std::exception& e) {
90489       {
90490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90491       };
90492     } catch (...) {
90493       {
90494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90495       };
90496     }
90497   }
90498 }
90499
90500
90501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
90502   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90503   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
90504
90505   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90506   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
90507   {
90508     try {
90509       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
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 void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
90528   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90529   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
90530
90531   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90532   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
90533   if (!arg2) {
90534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
90535     return ;
90536   }
90537   {
90538     try {
90539       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
90540     } catch (std::out_of_range& e) {
90541       {
90542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90543       };
90544     } catch (std::exception& e) {
90545       {
90546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90547       };
90548     } catch (...) {
90549       {
90550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90551       };
90552     }
90553   }
90554 }
90555
90556
90557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
90558   void * jresult ;
90559   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
90560
90561   {
90562     try {
90563       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
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 = (void *)result;
90579   return jresult;
90580 }
90581
90582
90583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
90584   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90585
90586   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90587   {
90588     try {
90589       delete arg1;
90590     } catch (std::out_of_range& e) {
90591       {
90592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90593       };
90594     } catch (std::exception& e) {
90595       {
90596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90597       };
90598     } catch (...) {
90599       {
90600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90601       };
90602     }
90603   }
90604 }
90605
90606
90607 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
90608   unsigned int jresult ;
90609   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90610   bool result;
90611
90612   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90613   {
90614     try {
90615       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
90616     } catch (std::out_of_range& e) {
90617       {
90618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90619       };
90620     } catch (std::exception& e) {
90621       {
90622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90623       };
90624     } catch (...) {
90625       {
90626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90627       };
90628     }
90629   }
90630   jresult = result;
90631   return jresult;
90632 }
90633
90634
90635 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
90636   unsigned long jresult ;
90637   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90638   std::size_t result;
90639
90640   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90641   {
90642     try {
90643       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
90644     } catch (std::out_of_range& e) {
90645       {
90646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90647       };
90648     } catch (std::exception& e) {
90649       {
90650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90651       };
90652     } catch (...) {
90653       {
90654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90655       };
90656     }
90657   }
90658   jresult = (unsigned long)result;
90659   return jresult;
90660 }
90661
90662
90663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
90664   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90665   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
90666
90667   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90668   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
90669   {
90670     try {
90671       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
90672     } catch (std::out_of_range& e) {
90673       {
90674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90675       };
90676     } catch (std::exception& e) {
90677       {
90678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90679       };
90680     } catch (...) {
90681       {
90682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90683       };
90684     }
90685   }
90686 }
90687
90688
90689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
90690   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90691   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
90692
90693   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90694   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
90695   {
90696     try {
90697       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
90698     } catch (std::out_of_range& e) {
90699       {
90700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90701       };
90702     } catch (std::exception& e) {
90703       {
90704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90705       };
90706     } catch (...) {
90707       {
90708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90709       };
90710     }
90711   }
90712 }
90713
90714
90715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
90716   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90717   Dali::Vector2 *arg2 = 0 ;
90718
90719   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90720   arg2 = (Dali::Vector2 *)jarg2;
90721   if (!arg2) {
90722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90723     return ;
90724   }
90725   {
90726     try {
90727       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
90728     } catch (std::out_of_range& e) {
90729       {
90730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90731       };
90732     } catch (std::exception& e) {
90733       {
90734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90735       };
90736     } catch (...) {
90737       {
90738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90739       };
90740     }
90741   }
90742 }
90743
90744
90745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
90746   void * jresult ;
90747   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
90748
90749   {
90750     try {
90751       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
90752     } catch (std::out_of_range& e) {
90753       {
90754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90755       };
90756     } catch (std::exception& e) {
90757       {
90758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90759       };
90760     } catch (...) {
90761       {
90762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90763       };
90764     }
90765   }
90766   jresult = (void *)result;
90767   return jresult;
90768 }
90769
90770
90771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
90772   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90773
90774   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90775   {
90776     try {
90777       delete arg1;
90778     } catch (std::out_of_range& e) {
90779       {
90780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90781       };
90782     } catch (std::exception& e) {
90783       {
90784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90785       };
90786     } catch (...) {
90787       {
90788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90789       };
90790     }
90791   }
90792 }
90793
90794
90795 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextEditorSignal_Empty(void * jarg1) {
90796   unsigned int jresult ;
90797   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90798   bool result;
90799
90800   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90801   {
90802     try {
90803       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
90804     } catch (std::out_of_range& e) {
90805       {
90806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90807       };
90808     } catch (std::exception& e) {
90809       {
90810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90811       };
90812     } catch (...) {
90813       {
90814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90815       };
90816     }
90817   }
90818   jresult = result;
90819   return jresult;
90820 }
90821
90822
90823 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextEditorSignal_GetConnectionCount(void * jarg1) {
90824   unsigned long jresult ;
90825   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90826   std::size_t result;
90827
90828   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90829   {
90830     try {
90831       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
90832     } catch (std::out_of_range& e) {
90833       {
90834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90835       };
90836     } catch (std::exception& e) {
90837       {
90838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90839       };
90840     } catch (...) {
90841       {
90842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90843       };
90844     }
90845   }
90846   jresult = (unsigned long)result;
90847   return jresult;
90848 }
90849
90850
90851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Connect(void * jarg1, void * jarg2) {
90852   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90853   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
90854
90855   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90856   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
90857   {
90858     try {
90859       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Connect(arg1,arg2);
90860     } catch (std::out_of_range& e) {
90861       {
90862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90863       };
90864     } catch (std::exception& e) {
90865       {
90866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90867       };
90868     } catch (...) {
90869       {
90870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90871       };
90872     }
90873   }
90874 }
90875
90876
90877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Disconnect(void * jarg1, void * jarg2) {
90878   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90879   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
90880
90881   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90882   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
90883   {
90884     try {
90885       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Disconnect(arg1,arg2);
90886     } catch (std::out_of_range& e) {
90887       {
90888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90889       };
90890     } catch (std::exception& e) {
90891       {
90892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90893       };
90894     } catch (...) {
90895       {
90896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90897       };
90898     }
90899   }
90900 }
90901
90902
90903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Emit(void * jarg1, void * jarg2) {
90904   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90905   Dali::Toolkit::TextEditor arg2 ;
90906   Dali::Toolkit::TextEditor *argp2 ;
90907
90908   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90909   argp2 = (Dali::Toolkit::TextEditor *)jarg2;
90910   if (!argp2) {
90911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextEditor", 0);
90912     return ;
90913   }
90914   arg2 = *argp2;
90915   {
90916     try {
90917       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(arg1,arg2);
90918     } catch (std::out_of_range& e) {
90919       {
90920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90921       };
90922     } catch (std::exception& e) {
90923       {
90924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90925       };
90926     } catch (...) {
90927       {
90928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90929       };
90930     }
90931   }
90932 }
90933
90934
90935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditorSignal() {
90936   void * jresult ;
90937   Dali::Signal< void (Dali::Toolkit::TextEditor) > *result = 0 ;
90938
90939   {
90940     try {
90941       result = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)new Dali::Signal< void (Dali::Toolkit::TextEditor) >();
90942     } catch (std::out_of_range& e) {
90943       {
90944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90945       };
90946     } catch (std::exception& e) {
90947       {
90948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90949       };
90950     } catch (...) {
90951       {
90952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90953       };
90954     }
90955   }
90956   jresult = (void *)result;
90957   return jresult;
90958 }
90959
90960
90961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditorSignal(void * jarg1) {
90962   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90963
90964   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90965   {
90966     try {
90967       delete arg1;
90968     } catch (std::out_of_range& e) {
90969       {
90970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90971       };
90972     } catch (std::exception& e) {
90973       {
90974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90975       };
90976     } catch (...) {
90977       {
90978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90979       };
90980     }
90981   }
90982 }
90983
90984
90985 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextFieldSignal_Empty(void * jarg1) {
90986   unsigned int jresult ;
90987   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90988   bool result;
90989
90990   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90991   {
90992     try {
90993       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
90994     } catch (std::out_of_range& e) {
90995       {
90996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90997       };
90998     } catch (std::exception& e) {
90999       {
91000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91001       };
91002     } catch (...) {
91003       {
91004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91005       };
91006     }
91007   }
91008   jresult = result;
91009   return jresult;
91010 }
91011
91012
91013 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextFieldSignal_GetConnectionCount(void * jarg1) {
91014   unsigned long jresult ;
91015   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91016   std::size_t result;
91017
91018   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91019   {
91020     try {
91021       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
91022     } catch (std::out_of_range& e) {
91023       {
91024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91025       };
91026     } catch (std::exception& e) {
91027       {
91028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91029       };
91030     } catch (...) {
91031       {
91032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91033       };
91034     }
91035   }
91036   jresult = (unsigned long)result;
91037   return jresult;
91038 }
91039
91040
91041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Connect(void * jarg1, void * jarg2) {
91042   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91043   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
91044
91045   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91046   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
91047   {
91048     try {
91049       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Connect(arg1,arg2);
91050     } catch (std::out_of_range& e) {
91051       {
91052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91053       };
91054     } catch (std::exception& e) {
91055       {
91056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91057       };
91058     } catch (...) {
91059       {
91060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91061       };
91062     }
91063   }
91064 }
91065
91066
91067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Disconnect(void * jarg1, void * jarg2) {
91068   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91069   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
91070
91071   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91072   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
91073   {
91074     try {
91075       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Disconnect(arg1,arg2);
91076     } catch (std::out_of_range& e) {
91077       {
91078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91079       };
91080     } catch (std::exception& e) {
91081       {
91082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91083       };
91084     } catch (...) {
91085       {
91086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91087       };
91088     }
91089   }
91090 }
91091
91092
91093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Emit(void * jarg1, void * jarg2) {
91094   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91095   Dali::Toolkit::TextField arg2 ;
91096   Dali::Toolkit::TextField *argp2 ;
91097
91098   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91099   argp2 = (Dali::Toolkit::TextField *)jarg2;
91100   if (!argp2) {
91101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextField", 0);
91102     return ;
91103   }
91104   arg2 = *argp2;
91105   {
91106     try {
91107       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(arg1,arg2);
91108     } catch (std::out_of_range& e) {
91109       {
91110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91111       };
91112     } catch (std::exception& e) {
91113       {
91114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91115       };
91116     } catch (...) {
91117       {
91118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91119       };
91120     }
91121   }
91122 }
91123
91124
91125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextFieldSignal() {
91126   void * jresult ;
91127   Dali::Signal< void (Dali::Toolkit::TextField) > *result = 0 ;
91128
91129   {
91130     try {
91131       result = (Dali::Signal< void (Dali::Toolkit::TextField) > *)new Dali::Signal< void (Dali::Toolkit::TextField) >();
91132     } catch (std::out_of_range& e) {
91133       {
91134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91135       };
91136     } catch (std::exception& e) {
91137       {
91138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91139       };
91140     } catch (...) {
91141       {
91142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91143       };
91144     }
91145   }
91146   jresult = (void *)result;
91147   return jresult;
91148 }
91149
91150
91151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextFieldSignal(void * jarg1) {
91152   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91153
91154   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91155   {
91156     try {
91157       delete arg1;
91158     } catch (std::out_of_range& e) {
91159       {
91160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91161       };
91162     } catch (std::exception& e) {
91163       {
91164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91165       };
91166     } catch (...) {
91167       {
91168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91169       };
91170     }
91171   }
91172 }
91173
91174
91175 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
91176   unsigned int jresult ;
91177   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91178   bool result;
91179
91180   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91181   {
91182     try {
91183       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);
91184     } catch (std::out_of_range& e) {
91185       {
91186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91187       };
91188     } catch (std::exception& e) {
91189       {
91190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91191       };
91192     } catch (...) {
91193       {
91194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91195       };
91196     }
91197   }
91198   jresult = result;
91199   return jresult;
91200 }
91201
91202
91203 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
91204   unsigned long jresult ;
91205   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91206   std::size_t result;
91207
91208   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91209   {
91210     try {
91211       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);
91212     } catch (std::out_of_range& e) {
91213       {
91214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91215       };
91216     } catch (std::exception& e) {
91217       {
91218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91219       };
91220     } catch (...) {
91221       {
91222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91223       };
91224     }
91225   }
91226   jresult = (unsigned long)result;
91227   return jresult;
91228 }
91229
91230
91231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
91232   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91233   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
91234
91235   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91236   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
91237   {
91238     try {
91239       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
91240     } catch (std::out_of_range& e) {
91241       {
91242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91243       };
91244     } catch (std::exception& e) {
91245       {
91246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91247       };
91248     } catch (...) {
91249       {
91250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91251       };
91252     }
91253   }
91254 }
91255
91256
91257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
91258   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91259   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
91260
91261   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91262   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
91263   {
91264     try {
91265       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
91266     } catch (std::out_of_range& e) {
91267       {
91268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91269       };
91270     } catch (std::exception& e) {
91271       {
91272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91273       };
91274     } catch (...) {
91275       {
91276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91277       };
91278     }
91279   }
91280 }
91281
91282
91283 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
91284   unsigned int jresult ;
91285   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91286   Dali::Toolkit::Control arg2 ;
91287   Dali::KeyEvent *arg3 = 0 ;
91288   Dali::Toolkit::Control *argp2 ;
91289   bool result;
91290
91291   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91292   argp2 = (Dali::Toolkit::Control *)jarg2;
91293   if (!argp2) {
91294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
91295     return 0;
91296   }
91297   arg2 = *argp2;
91298   arg3 = (Dali::KeyEvent *)jarg3;
91299   if (!arg3) {
91300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
91301     return 0;
91302   }
91303   {
91304     try {
91305       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);
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 void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
91326   void * jresult ;
91327   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
91328
91329   {
91330     try {
91331       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
91332     } catch (std::out_of_range& e) {
91333       {
91334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91335       };
91336     } catch (std::exception& e) {
91337       {
91338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91339       };
91340     } catch (...) {
91341       {
91342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91343       };
91344     }
91345   }
91346   jresult = (void *)result;
91347   return jresult;
91348 }
91349
91350
91351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
91352   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91353
91354   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91355   {
91356     try {
91357       delete arg1;
91358     } catch (std::out_of_range& e) {
91359       {
91360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91361       };
91362     } catch (std::exception& e) {
91363       {
91364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91365       };
91366     } catch (...) {
91367       {
91368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91369       };
91370     }
91371   }
91372 }
91373
91374
91375 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
91376   unsigned int jresult ;
91377   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91378   bool result;
91379
91380   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91381   {
91382     try {
91383       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
91384     } catch (std::out_of_range& e) {
91385       {
91386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91387       };
91388     } catch (std::exception& e) {
91389       {
91390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91391       };
91392     } catch (...) {
91393       {
91394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91395       };
91396     }
91397   }
91398   jresult = result;
91399   return jresult;
91400 }
91401
91402
91403 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
91404   unsigned long jresult ;
91405   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91406   std::size_t result;
91407
91408   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91409   {
91410     try {
91411       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
91412     } catch (std::out_of_range& e) {
91413       {
91414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91415       };
91416     } catch (std::exception& e) {
91417       {
91418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91419       };
91420     } catch (...) {
91421       {
91422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91423       };
91424     }
91425   }
91426   jresult = (unsigned long)result;
91427   return jresult;
91428 }
91429
91430
91431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
91432   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91433   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
91434
91435   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91436   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
91437   {
91438     try {
91439       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
91440     } catch (std::out_of_range& e) {
91441       {
91442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91443       };
91444     } catch (std::exception& e) {
91445       {
91446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91447       };
91448     } catch (...) {
91449       {
91450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91451       };
91452     }
91453   }
91454 }
91455
91456
91457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
91458   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91459   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
91460
91461   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91462   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
91463   {
91464     try {
91465       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
91466     } catch (std::out_of_range& e) {
91467       {
91468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91469       };
91470     } catch (std::exception& e) {
91471       {
91472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91473       };
91474     } catch (...) {
91475       {
91476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91477       };
91478     }
91479   }
91480 }
91481
91482
91483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
91484   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91485   Dali::Toolkit::Control arg2 ;
91486   Dali::Toolkit::Control *argp2 ;
91487
91488   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91489   argp2 = (Dali::Toolkit::Control *)jarg2;
91490   if (!argp2) {
91491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
91492     return ;
91493   }
91494   arg2 = *argp2;
91495   {
91496     try {
91497       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
91498     } catch (std::out_of_range& e) {
91499       {
91500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91501       };
91502     } catch (std::exception& e) {
91503       {
91504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91505       };
91506     } catch (...) {
91507       {
91508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91509       };
91510     }
91511   }
91512 }
91513
91514
91515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
91516   void * jresult ;
91517   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
91518
91519   {
91520     try {
91521       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
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 = (void *)result;
91537   return jresult;
91538 }
91539
91540
91541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
91542   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91543
91544   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91545   {
91546     try {
91547       delete arg1;
91548     } catch (std::out_of_range& e) {
91549       {
91550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91551       };
91552     } catch (std::exception& e) {
91553       {
91554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91555       };
91556     } catch (...) {
91557       {
91558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91559       };
91560     }
91561   }
91562 }
91563
91564
91565 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
91566   unsigned int jresult ;
91567   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91568   bool result;
91569
91570   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91571   {
91572     try {
91573       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
91574     } catch (std::out_of_range& e) {
91575       {
91576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91577       };
91578     } catch (std::exception& e) {
91579       {
91580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91581       };
91582     } catch (...) {
91583       {
91584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91585       };
91586     }
91587   }
91588   jresult = result;
91589   return jresult;
91590 }
91591
91592
91593 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
91594   unsigned long jresult ;
91595   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91596   std::size_t result;
91597
91598   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91599   {
91600     try {
91601       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
91602     } catch (std::out_of_range& e) {
91603       {
91604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91605       };
91606     } catch (std::exception& e) {
91607       {
91608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91609       };
91610     } catch (...) {
91611       {
91612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91613       };
91614     }
91615   }
91616   jresult = (unsigned long)result;
91617   return jresult;
91618 }
91619
91620
91621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
91622   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91623   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
91624
91625   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91626   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
91627   {
91628     try {
91629       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
91630     } catch (std::out_of_range& e) {
91631       {
91632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91633       };
91634     } catch (std::exception& e) {
91635       {
91636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91637       };
91638     } catch (...) {
91639       {
91640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91641       };
91642     }
91643   }
91644 }
91645
91646
91647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
91648   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91649   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
91650
91651   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91652   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
91653   {
91654     try {
91655       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
91656     } catch (std::out_of_range& e) {
91657       {
91658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91659       };
91660     } catch (std::exception& e) {
91661       {
91662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91663       };
91664     } catch (...) {
91665       {
91666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91667       };
91668     }
91669   }
91670 }
91671
91672
91673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
91674   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91675   Dali::Toolkit::VideoView *arg2 = 0 ;
91676
91677   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91678   arg2 = (Dali::Toolkit::VideoView *)jarg2;
91679   if (!arg2) {
91680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
91681     return ;
91682   }
91683   {
91684     try {
91685       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
91686     } catch (std::out_of_range& e) {
91687       {
91688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91689       };
91690     } catch (std::exception& e) {
91691       {
91692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91693       };
91694     } catch (...) {
91695       {
91696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91697       };
91698     }
91699   }
91700 }
91701
91702
91703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
91704   void * jresult ;
91705   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
91706
91707   {
91708     try {
91709       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
91710     } catch (std::out_of_range& e) {
91711       {
91712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91713       };
91714     } catch (std::exception& e) {
91715       {
91716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91717       };
91718     } catch (...) {
91719       {
91720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91721       };
91722     }
91723   }
91724   jresult = (void *)result;
91725   return jresult;
91726 }
91727
91728
91729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
91730   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91731
91732   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91733   {
91734     try {
91735       delete arg1;
91736     } catch (std::out_of_range& e) {
91737       {
91738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91739       };
91740     } catch (std::exception& e) {
91741       {
91742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91743       };
91744     } catch (...) {
91745       {
91746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91747       };
91748     }
91749   }
91750 }
91751
91752
91753 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
91754   unsigned int jresult ;
91755   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91756   bool result;
91757
91758   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91759   {
91760     try {
91761       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
91762     } catch (std::out_of_range& e) {
91763       {
91764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91765       };
91766     } catch (std::exception& e) {
91767       {
91768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91769       };
91770     } catch (...) {
91771       {
91772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91773       };
91774     }
91775   }
91776   jresult = result;
91777   return jresult;
91778 }
91779
91780
91781 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
91782   unsigned long jresult ;
91783   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91784   std::size_t result;
91785
91786   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91787   {
91788     try {
91789       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
91790     } catch (std::out_of_range& e) {
91791       {
91792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91793       };
91794     } catch (std::exception& e) {
91795       {
91796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91797       };
91798     } catch (...) {
91799       {
91800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91801       };
91802     }
91803   }
91804   jresult = (unsigned long)result;
91805   return jresult;
91806 }
91807
91808
91809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
91810   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91811   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
91812
91813   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91814   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
91815   {
91816     try {
91817       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
91818     } catch (std::out_of_range& e) {
91819       {
91820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91821       };
91822     } catch (std::exception& e) {
91823       {
91824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91825       };
91826     } catch (...) {
91827       {
91828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91829       };
91830     }
91831   }
91832 }
91833
91834
91835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
91836   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91837   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
91838
91839   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91840   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
91841   {
91842     try {
91843       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
91844     } catch (std::out_of_range& e) {
91845       {
91846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91847       };
91848     } catch (std::exception& e) {
91849       {
91850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91851       };
91852     } catch (...) {
91853       {
91854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91855       };
91856     }
91857   }
91858 }
91859
91860
91861 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
91862   unsigned int jresult ;
91863   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91864   Dali::Toolkit::Slider arg2 ;
91865   float arg3 ;
91866   Dali::Toolkit::Slider *argp2 ;
91867   bool result;
91868
91869   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91870   argp2 = (Dali::Toolkit::Slider *)jarg2;
91871   if (!argp2) {
91872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
91873     return 0;
91874   }
91875   arg2 = *argp2;
91876   arg3 = (float)jarg3;
91877   {
91878     try {
91879       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
91880     } catch (std::out_of_range& e) {
91881       {
91882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91883       };
91884     } catch (std::exception& e) {
91885       {
91886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91887       };
91888     } catch (...) {
91889       {
91890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91891       };
91892     }
91893   }
91894   jresult = result;
91895   return jresult;
91896 }
91897
91898
91899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
91900   void * jresult ;
91901   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
91902
91903   {
91904     try {
91905       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
91906     } catch (std::out_of_range& e) {
91907       {
91908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91909       };
91910     } catch (std::exception& e) {
91911       {
91912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91913       };
91914     } catch (...) {
91915       {
91916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91917       };
91918     }
91919   }
91920   jresult = (void *)result;
91921   return jresult;
91922 }
91923
91924
91925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
91926   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91927
91928   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91929   {
91930     try {
91931       delete arg1;
91932     } catch (std::out_of_range& e) {
91933       {
91934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91935       };
91936     } catch (std::exception& e) {
91937       {
91938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91939       };
91940     } catch (...) {
91941       {
91942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91943       };
91944     }
91945   }
91946 }
91947
91948
91949 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
91950   unsigned int jresult ;
91951   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91952   bool result;
91953
91954   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91955   {
91956     try {
91957       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
91958     } catch (std::out_of_range& e) {
91959       {
91960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91961       };
91962     } catch (std::exception& e) {
91963       {
91964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91965       };
91966     } catch (...) {
91967       {
91968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91969       };
91970     }
91971   }
91972   jresult = result;
91973   return jresult;
91974 }
91975
91976
91977 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
91978   unsigned long jresult ;
91979   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91980   std::size_t result;
91981
91982   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91983   {
91984     try {
91985       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
91986     } catch (std::out_of_range& e) {
91987       {
91988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91989       };
91990     } catch (std::exception& e) {
91991       {
91992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91993       };
91994     } catch (...) {
91995       {
91996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91997       };
91998     }
91999   }
92000   jresult = (unsigned long)result;
92001   return jresult;
92002 }
92003
92004
92005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
92006   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92007   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
92008
92009   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92010   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
92011   {
92012     try {
92013       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
92014     } catch (std::out_of_range& e) {
92015       {
92016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92017       };
92018     } catch (std::exception& e) {
92019       {
92020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92021       };
92022     } catch (...) {
92023       {
92024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92025       };
92026     }
92027   }
92028 }
92029
92030
92031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
92032   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92033   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
92034
92035   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92036   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
92037   {
92038     try {
92039       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
92040     } catch (std::out_of_range& e) {
92041       {
92042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92043       };
92044     } catch (std::exception& e) {
92045       {
92046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92047       };
92048     } catch (...) {
92049       {
92050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92051       };
92052     }
92053   }
92054 }
92055
92056
92057 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
92058   unsigned int jresult ;
92059   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92060   Dali::Toolkit::Slider arg2 ;
92061   int arg3 ;
92062   Dali::Toolkit::Slider *argp2 ;
92063   bool result;
92064
92065   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92066   argp2 = (Dali::Toolkit::Slider *)jarg2;
92067   if (!argp2) {
92068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
92069     return 0;
92070   }
92071   arg2 = *argp2;
92072   arg3 = (int)jarg3;
92073   {
92074     try {
92075       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
92076     } catch (std::out_of_range& e) {
92077       {
92078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92079       };
92080     } catch (std::exception& e) {
92081       {
92082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92083       };
92084     } catch (...) {
92085       {
92086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92087       };
92088     }
92089   }
92090   jresult = result;
92091   return jresult;
92092 }
92093
92094
92095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
92096   void * jresult ;
92097   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
92098
92099   {
92100     try {
92101       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
92102     } catch (std::out_of_range& e) {
92103       {
92104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92105       };
92106     } catch (std::exception& e) {
92107       {
92108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92109       };
92110     } catch (...) {
92111       {
92112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92113       };
92114     }
92115   }
92116   jresult = (void *)result;
92117   return jresult;
92118 }
92119
92120
92121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
92122   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92123
92124   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92125   {
92126     try {
92127       delete arg1;
92128     } catch (std::out_of_range& e) {
92129       {
92130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92131       };
92132     } catch (std::exception& e) {
92133       {
92134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92135       };
92136     } catch (...) {
92137       {
92138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92139       };
92140     }
92141   }
92142 }
92143
92144
92145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
92146   void * jresult ;
92147   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92148
92149   {
92150     try {
92151       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
92152     } catch (std::out_of_range& e) {
92153       {
92154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92155       };
92156     } catch (std::exception& e) {
92157       {
92158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92159       };
92160     } catch (...) {
92161       {
92162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92163       };
92164     }
92165   }
92166   jresult = (void *)result;
92167   return jresult;
92168 }
92169
92170
92171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
92172   void * jresult ;
92173   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
92174   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92175
92176   arg1 = (Dali::Toolkit::Ruler *)jarg1;
92177   {
92178     try {
92179       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
92180     } catch (std::out_of_range& e) {
92181       {
92182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92183       };
92184     } catch (std::exception& e) {
92185       {
92186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92187       };
92188     } catch (...) {
92189       {
92190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92191       };
92192     }
92193   }
92194   jresult = (void *)result;
92195   return jresult;
92196 }
92197
92198
92199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
92200   void * jresult ;
92201   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
92202   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92203
92204   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92205   if (!arg1) {
92206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
92207     return 0;
92208   }
92209   {
92210     try {
92211       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
92212     } catch (std::out_of_range& e) {
92213       {
92214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92215       };
92216     } catch (std::exception& e) {
92217       {
92218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92219       };
92220     } catch (...) {
92221       {
92222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92223       };
92224     }
92225   }
92226   jresult = (void *)result;
92227   return jresult;
92228 }
92229
92230
92231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
92232   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92233
92234   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92235   {
92236     try {
92237       delete arg1;
92238     } catch (std::out_of_range& e) {
92239       {
92240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92241       };
92242     } catch (std::exception& e) {
92243       {
92244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92245       };
92246     } catch (...) {
92247       {
92248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92249       };
92250     }
92251   }
92252 }
92253
92254
92255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
92256   void * jresult ;
92257   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92258   Dali::Toolkit::Ruler *result = 0 ;
92259
92260   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92261   {
92262     try {
92263       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
92264     } catch (std::out_of_range& e) {
92265       {
92266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92267       };
92268     } catch (std::exception& e) {
92269       {
92270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92271       };
92272     } catch (...) {
92273       {
92274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92275       };
92276     }
92277   }
92278   jresult = (void *)result;
92279   return jresult;
92280 }
92281
92282
92283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
92284   void * jresult ;
92285   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92286   Dali::Toolkit::Ruler *result = 0 ;
92287
92288   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92289   {
92290     try {
92291       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
92292     } catch (std::out_of_range& e) {
92293       {
92294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92295       };
92296     } catch (std::exception& e) {
92297       {
92298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92299       };
92300     } catch (...) {
92301       {
92302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92303       };
92304     }
92305   }
92306   jresult = (void *)result;
92307   return jresult;
92308 }
92309
92310
92311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
92312   void * jresult ;
92313   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92314   Dali::Toolkit::Ruler *result = 0 ;
92315
92316   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92317   {
92318     try {
92319       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
92320     } catch (std::out_of_range& e) {
92321       {
92322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92323       };
92324     } catch (std::exception& e) {
92325       {
92326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92327       };
92328     } catch (...) {
92329       {
92330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92331       };
92332     }
92333   }
92334   jresult = (void *)result;
92335   return jresult;
92336 }
92337
92338
92339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
92340   void * jresult ;
92341   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92342   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
92343   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92344
92345   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92346   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
92347   if (!arg2) {
92348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
92349     return 0;
92350   }
92351   {
92352     try {
92353       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
92354     } catch (std::out_of_range& e) {
92355       {
92356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92357       };
92358     } catch (std::exception& e) {
92359       {
92360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92361       };
92362     } catch (...) {
92363       {
92364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92365       };
92366     }
92367   }
92368   jresult = (void *)result;
92369   return jresult;
92370 }
92371
92372
92373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
92374   void * jresult ;
92375   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92376   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
92377   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92378
92379   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92380   arg2 = (Dali::Toolkit::Ruler *)jarg2;
92381   {
92382     try {
92383       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
92384     } catch (std::out_of_range& e) {
92385       {
92386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92387       };
92388     } catch (std::exception& e) {
92389       {
92390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92391       };
92392     } catch (...) {
92393       {
92394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92395       };
92396     }
92397   }
92398   jresult = (void *)result;
92399   return jresult;
92400 }
92401
92402
92403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
92404   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92405
92406   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92407   {
92408     try {
92409       (arg1)->Reset();
92410     } catch (std::out_of_range& e) {
92411       {
92412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92413       };
92414     } catch (std::exception& e) {
92415       {
92416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92417       };
92418     } catch (...) {
92419       {
92420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92421       };
92422     }
92423   }
92424 }
92425
92426
92427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
92428   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92429   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
92430
92431   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92432   arg2 = (Dali::Toolkit::Ruler *)jarg2;
92433   {
92434     try {
92435       (arg1)->Reset(arg2);
92436     } catch (std::out_of_range& e) {
92437       {
92438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92439       };
92440     } catch (std::exception& e) {
92441       {
92442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92443       };
92444     } catch (...) {
92445       {
92446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92447       };
92448     }
92449   }
92450 }
92451
92452
92453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
92454   void * jresult ;
92455   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92456   Dali::Toolkit::Ruler *result = 0 ;
92457
92458   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92459   {
92460     try {
92461       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
92462     } catch (std::out_of_range& e) {
92463       {
92464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92465       };
92466     } catch (std::exception& e) {
92467       {
92468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92469       };
92470     } catch (...) {
92471       {
92472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92473       };
92474     }
92475   }
92476   jresult = (void *)result;
92477   return jresult;
92478 }
92479
92480
92481 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
92482   float jresult ;
92483   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92484   float arg2 ;
92485   float arg3 ;
92486   float result;
92487
92488   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92489   arg2 = (float)jarg2;
92490   arg3 = (float)jarg3;
92491   {
92492     try {
92493       result = (float)(*arg1)->Snap(arg2,arg3);
92494     } catch (std::out_of_range& e) {
92495       {
92496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92497       };
92498     } catch (std::exception& e) {
92499       {
92500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92501       };
92502     } catch (...) {
92503       {
92504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92505       };
92506     }
92507   }
92508   jresult = result;
92509   return jresult;
92510 }
92511
92512
92513 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
92514   float jresult ;
92515   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92516   float arg2 ;
92517   float result;
92518
92519   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92520   arg2 = (float)jarg2;
92521   {
92522     try {
92523       result = (float)(*arg1)->Snap(arg2);
92524     } catch (std::out_of_range& e) {
92525       {
92526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92527       };
92528     } catch (std::exception& e) {
92529       {
92530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92531       };
92532     } catch (...) {
92533       {
92534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92535       };
92536     }
92537   }
92538   jresult = result;
92539   return jresult;
92540 }
92541
92542
92543 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
92544   float jresult ;
92545   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92546   unsigned int arg2 ;
92547   unsigned int *arg3 = 0 ;
92548   bool arg4 ;
92549   float result;
92550
92551   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92552   arg2 = (unsigned int)jarg2;
92553   arg3 = (unsigned int *)jarg3;
92554   arg4 = jarg4 ? true : false;
92555   {
92556     try {
92557       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
92558     } catch (std::out_of_range& e) {
92559       {
92560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92561       };
92562     } catch (std::exception& e) {
92563       {
92564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92565       };
92566     } catch (...) {
92567       {
92568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92569       };
92570     }
92571   }
92572   jresult = result;
92573   return jresult;
92574 }
92575
92576
92577 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
92578   unsigned int jresult ;
92579   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92580   float arg2 ;
92581   bool arg3 ;
92582   unsigned int result;
92583
92584   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92585   arg2 = (float)jarg2;
92586   arg3 = jarg3 ? true : false;
92587   {
92588     try {
92589       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
92590     } catch (std::out_of_range& e) {
92591       {
92592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92593       };
92594     } catch (std::exception& e) {
92595       {
92596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92597       };
92598     } catch (...) {
92599       {
92600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92601       };
92602     }
92603   }
92604   jresult = result;
92605   return jresult;
92606 }
92607
92608
92609 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
92610   unsigned int jresult ;
92611   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92612   unsigned int result;
92613
92614   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92615   {
92616     try {
92617       result = (unsigned int)(*arg1)->GetTotalPages();
92618     } catch (std::out_of_range& e) {
92619       {
92620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92621       };
92622     } catch (std::exception& e) {
92623       {
92624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92625       };
92626     } catch (...) {
92627       {
92628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92629       };
92630     }
92631   }
92632   jresult = result;
92633   return jresult;
92634 }
92635
92636
92637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
92638   int jresult ;
92639   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92640   Dali::Toolkit::Ruler::RulerType result;
92641
92642   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92643   {
92644     try {
92645       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
92646     } catch (std::out_of_range& e) {
92647       {
92648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92649       };
92650     } catch (std::exception& e) {
92651       {
92652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92653       };
92654     } catch (...) {
92655       {
92656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92657       };
92658     }
92659   }
92660   jresult = (int)result;
92661   return jresult;
92662 }
92663
92664
92665 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
92666   unsigned int jresult ;
92667   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92668   bool result;
92669
92670   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92671   {
92672     try {
92673       result = (bool)(*arg1)->IsEnabled();
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 void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
92694   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92695
92696   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92697   {
92698     try {
92699       (*arg1)->Enable();
92700     } catch (std::out_of_range& e) {
92701       {
92702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92703       };
92704     } catch (std::exception& e) {
92705       {
92706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92707       };
92708     } catch (...) {
92709       {
92710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92711       };
92712     }
92713   }
92714 }
92715
92716
92717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
92718   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92719
92720   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92721   {
92722     try {
92723       (*arg1)->Disable();
92724     } catch (std::out_of_range& e) {
92725       {
92726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92727       };
92728     } catch (std::exception& e) {
92729       {
92730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92731       };
92732     } catch (...) {
92733       {
92734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92735       };
92736     }
92737   }
92738 }
92739
92740
92741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
92742   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92743   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
92744   Dali::Toolkit::RulerDomain *argp2 ;
92745
92746   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92747   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
92748   if (!argp2) {
92749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
92750     return ;
92751   }
92752   arg2 = *argp2;
92753   {
92754     try {
92755       (*arg1)->SetDomain(arg2);
92756     } catch (std::out_of_range& e) {
92757       {
92758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92759       };
92760     } catch (std::exception& e) {
92761       {
92762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92763       };
92764     } catch (...) {
92765       {
92766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92767       };
92768     }
92769   }
92770 }
92771
92772
92773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
92774   void * jresult ;
92775   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92776   Dali::Toolkit::RulerDomain *result = 0 ;
92777
92778   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92779   {
92780     try {
92781       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
92782     } catch (std::out_of_range& e) {
92783       {
92784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92785       };
92786     } catch (std::exception& e) {
92787       {
92788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92789       };
92790     } catch (...) {
92791       {
92792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92793       };
92794     }
92795   }
92796   jresult = (void *)result;
92797   return jresult;
92798 }
92799
92800
92801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
92802   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92803
92804   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92805   {
92806     try {
92807       (*arg1)->DisableDomain();
92808     } catch (std::out_of_range& e) {
92809       {
92810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92811       };
92812     } catch (std::exception& e) {
92813       {
92814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92815       };
92816     } catch (...) {
92817       {
92818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92819       };
92820     }
92821   }
92822 }
92823
92824
92825 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
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 result;
92832
92833   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92834   arg2 = (float)jarg2;
92835   arg3 = (float)jarg3;
92836   arg4 = (float)jarg4;
92837   {
92838     try {
92839       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
92840     } catch (std::out_of_range& e) {
92841       {
92842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92843       };
92844     } catch (std::exception& e) {
92845       {
92846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92847       };
92848     } catch (...) {
92849       {
92850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92851       };
92852     }
92853   }
92854   jresult = result;
92855   return jresult;
92856 }
92857
92858
92859 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
92860   float jresult ;
92861   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92862   float arg2 ;
92863   float arg3 ;
92864   float result;
92865
92866   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92867   arg2 = (float)jarg2;
92868   arg3 = (float)jarg3;
92869   {
92870     try {
92871       result = (float)(*arg1)->Clamp(arg2,arg3);
92872     } catch (std::out_of_range& e) {
92873       {
92874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92875       };
92876     } catch (std::exception& e) {
92877       {
92878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92879       };
92880     } catch (...) {
92881       {
92882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92883       };
92884     }
92885   }
92886   jresult = result;
92887   return jresult;
92888 }
92889
92890
92891 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
92892   float jresult ;
92893   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92894   float arg2 ;
92895   float result;
92896
92897   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92898   arg2 = (float)jarg2;
92899   {
92900     try {
92901       result = (float)(*arg1)->Clamp(arg2);
92902     } catch (std::out_of_range& e) {
92903       {
92904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92905       };
92906     } catch (std::exception& e) {
92907       {
92908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92909       };
92910     } catch (...) {
92911       {
92912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92913       };
92914     }
92915   }
92916   jresult = result;
92917   return jresult;
92918 }
92919
92920
92921 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
92922   float jresult ;
92923   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92924   float arg2 ;
92925   float arg3 ;
92926   float arg4 ;
92927   Dali::Toolkit::ClampState *arg5 = 0 ;
92928   float result;
92929
92930   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92931   arg2 = (float)jarg2;
92932   arg3 = (float)jarg3;
92933   arg4 = (float)jarg4;
92934   arg5 = (Dali::Toolkit::ClampState *)jarg5;
92935   if (!arg5) {
92936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
92937     return 0;
92938   }
92939   {
92940     try {
92941       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
92942     } catch (std::out_of_range& e) {
92943       {
92944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92945       };
92946     } catch (std::exception& e) {
92947       {
92948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92949       };
92950     } catch (...) {
92951       {
92952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92953       };
92954     }
92955   }
92956   jresult = result;
92957   return jresult;
92958 }
92959
92960
92961 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
92962   float jresult ;
92963   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92964   float arg2 ;
92965   float arg3 ;
92966   float arg4 ;
92967   float arg5 ;
92968   float result;
92969
92970   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92971   arg2 = (float)jarg2;
92972   arg3 = (float)jarg3;
92973   arg4 = (float)jarg4;
92974   arg5 = (float)jarg5;
92975   {
92976     try {
92977       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
92978     } catch (std::out_of_range& e) {
92979       {
92980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92981       };
92982     } catch (std::exception& e) {
92983       {
92984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92985       };
92986     } catch (...) {
92987       {
92988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92989       };
92990     }
92991   }
92992   jresult = result;
92993   return jresult;
92994 }
92995
92996
92997 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
92998   float jresult ;
92999   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93000   float arg2 ;
93001   float arg3 ;
93002   float arg4 ;
93003   float result;
93004
93005   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93006   arg2 = (float)jarg2;
93007   arg3 = (float)jarg3;
93008   arg4 = (float)jarg4;
93009   {
93010     try {
93011       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
93012     } catch (std::out_of_range& e) {
93013       {
93014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93015       };
93016     } catch (std::exception& e) {
93017       {
93018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93019       };
93020     } catch (...) {
93021       {
93022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93023       };
93024     }
93025   }
93026   jresult = result;
93027   return jresult;
93028 }
93029
93030
93031 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
93032   float jresult ;
93033   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93034   float arg2 ;
93035   float arg3 ;
93036   float result;
93037
93038   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93039   arg2 = (float)jarg2;
93040   arg3 = (float)jarg3;
93041   {
93042     try {
93043       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
93044     } catch (std::out_of_range& e) {
93045       {
93046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93047       };
93048     } catch (std::exception& e) {
93049       {
93050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93051       };
93052     } catch (...) {
93053       {
93054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93055       };
93056     }
93057   }
93058   jresult = result;
93059   return jresult;
93060 }
93061
93062
93063 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
93064   float jresult ;
93065   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93066   float arg2 ;
93067   float result;
93068
93069   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93070   arg2 = (float)jarg2;
93071   {
93072     try {
93073       result = (float)(*arg1)->SnapAndClamp(arg2);
93074     } catch (std::out_of_range& e) {
93075       {
93076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93077       };
93078     } catch (std::exception& e) {
93079       {
93080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93081       };
93082     } catch (...) {
93083       {
93084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93085       };
93086     }
93087   }
93088   jresult = result;
93089   return jresult;
93090 }
93091
93092
93093 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
93094   float jresult ;
93095   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93096   float arg2 ;
93097   float arg3 ;
93098   float arg4 ;
93099   float arg5 ;
93100   Dali::Toolkit::ClampState *arg6 = 0 ;
93101   float result;
93102
93103   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93104   arg2 = (float)jarg2;
93105   arg3 = (float)jarg3;
93106   arg4 = (float)jarg4;
93107   arg5 = (float)jarg5;
93108   arg6 = (Dali::Toolkit::ClampState *)jarg6;
93109   if (!arg6) {
93110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
93111     return 0;
93112   }
93113   {
93114     try {
93115       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
93116     } catch (std::out_of_range& e) {
93117       {
93118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93119       };
93120     } catch (std::exception& e) {
93121       {
93122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93123       };
93124     } catch (...) {
93125       {
93126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93127       };
93128     }
93129   }
93130   jresult = result;
93131   return jresult;
93132 }
93133
93134
93135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
93136   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93137
93138   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93139   {
93140     try {
93141       (*arg1)->Reference();
93142     } catch (std::out_of_range& e) {
93143       {
93144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93145       };
93146     } catch (std::exception& e) {
93147       {
93148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93149       };
93150     } catch (...) {
93151       {
93152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93153       };
93154     }
93155   }
93156 }
93157
93158
93159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
93160   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93161
93162   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93163   {
93164     try {
93165       (*arg1)->Unreference();
93166     } catch (std::out_of_range& e) {
93167       {
93168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93169       };
93170     } catch (std::exception& e) {
93171       {
93172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93173       };
93174     } catch (...) {
93175       {
93176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93177       };
93178     }
93179   }
93180 }
93181
93182
93183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
93184   int jresult ;
93185   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93186   int result;
93187
93188   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93189   {
93190     try {
93191       result = (int)(*arg1)->ReferenceCount();
93192     } catch (std::out_of_range& e) {
93193       {
93194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93195       };
93196     } catch (std::exception& e) {
93197       {
93198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93199       };
93200     } catch (...) {
93201       {
93202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93203       };
93204     }
93205   }
93206   jresult = result;
93207   return jresult;
93208 }
93209
93210
93211 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
93212   unsigned int jresult ;
93213   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93214   bool result;
93215
93216   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93217   {
93218     try {
93219       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
93220     } catch (std::out_of_range& e) {
93221       {
93222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93223       };
93224     } catch (std::exception& e) {
93225       {
93226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93227       };
93228     } catch (...) {
93229       {
93230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93231       };
93232     }
93233   }
93234   jresult = result;
93235   return jresult;
93236 }
93237
93238
93239 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
93240   unsigned long jresult ;
93241   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93242   std::size_t result;
93243
93244   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93245   {
93246     try {
93247       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
93248     } catch (std::out_of_range& e) {
93249       {
93250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93251       };
93252     } catch (std::exception& e) {
93253       {
93254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93255       };
93256     } catch (...) {
93257       {
93258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93259       };
93260     }
93261   }
93262   jresult = (unsigned long)result;
93263   return jresult;
93264 }
93265
93266
93267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
93268   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93269   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
93270
93271   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93272   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
93273   {
93274     try {
93275       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
93276     } catch (std::out_of_range& e) {
93277       {
93278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93279       };
93280     } catch (std::exception& e) {
93281       {
93282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93283       };
93284     } catch (...) {
93285       {
93286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93287       };
93288     }
93289   }
93290 }
93291
93292
93293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
93294   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93295   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
93296
93297   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93298   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
93299   {
93300     try {
93301       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
93302     } catch (std::out_of_range& e) {
93303       {
93304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93305       };
93306     } catch (std::exception& e) {
93307       {
93308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93309       };
93310     } catch (...) {
93311       {
93312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93313       };
93314     }
93315   }
93316 }
93317
93318
93319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
93320   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93321   Dali::Toolkit::Control arg2 ;
93322   Dali::Toolkit::Control *argp2 ;
93323
93324   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93325   argp2 = (Dali::Toolkit::Control *)jarg2;
93326   if (!argp2) {
93327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
93328     return ;
93329   }
93330   arg2 = *argp2;
93331   {
93332     try {
93333       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
93334     } catch (std::out_of_range& e) {
93335       {
93336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93337       };
93338     } catch (std::exception& e) {
93339       {
93340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93341       };
93342     } catch (...) {
93343       {
93344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93345       };
93346     }
93347   }
93348 }
93349
93350
93351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
93352   void * jresult ;
93353   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
93354
93355   {
93356     try {
93357       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
93358     } catch (std::out_of_range& e) {
93359       {
93360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93361       };
93362     } catch (std::exception& e) {
93363       {
93364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93365       };
93366     } catch (...) {
93367       {
93368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93369       };
93370     }
93371   }
93372   jresult = (void *)result;
93373   return jresult;
93374 }
93375
93376
93377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
93378   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93379
93380   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93381   {
93382     try {
93383       delete arg1;
93384     } catch (std::out_of_range& e) {
93385       {
93386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93387       };
93388     } catch (std::exception& e) {
93389       {
93390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93391       };
93392     } catch (...) {
93393       {
93394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93395       };
93396     }
93397   }
93398 }
93399
93400 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
93401     return (Dali::RefObject *)jarg1;
93402 }
93403
93404 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
93405     return (Dali::SignalObserver *)jarg1;
93406 }
93407
93408 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
93409     return (Dali::ConnectionTrackerInterface *)jarg1;
93410 }
93411
93412 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
93413     return (Dali::BaseHandle *)jarg1;
93414 }
93415
93416 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
93417     return (Dali::BaseHandle *)jarg1;
93418 }
93419
93420 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
93421     return (Dali::BaseHandle *)jarg1;
93422 }
93423
93424 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
93425     return (Dali::BaseHandle *)jarg1;
93426 }
93427
93428 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
93429     return (Dali::BaseHandle *)jarg1;
93430 }
93431
93432 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
93433     return (Dali::BaseHandle *)jarg1;
93434 }
93435
93436 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
93437     return (Dali::BaseHandle *)jarg1;
93438 }
93439
93440 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
93441     return (Dali::BaseHandle *)jarg1;
93442 }
93443
93444 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
93445     return (Dali::BaseHandle *)jarg1;
93446 }
93447
93448 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
93449     return (Dali::BaseHandle *)jarg1;
93450 }
93451
93452 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
93453     return (Dali::BaseHandle *)jarg1;
93454 }
93455
93456 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
93457     return (Dali::BaseHandle *)jarg1;
93458 }
93459
93460 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
93461     return (Dali::BaseHandle *)jarg1;
93462 }
93463
93464 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
93465     return (Dali::Handle *)jarg1;
93466 }
93467
93468 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
93469     return (Dali::Handle *)jarg1;
93470 }
93471
93472 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
93473     return (Dali::BaseHandle *)jarg1;
93474 }
93475
93476 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
93477     return (Dali::BaseHandle *)jarg1;
93478 }
93479
93480 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
93481     return (Dali::Handle *)jarg1;
93482 }
93483
93484 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
93485     return (Dali::BaseHandle *)jarg1;
93486 }
93487
93488 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
93489     return (Dali::Handle *)jarg1;
93490 }
93491
93492 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
93493     return (Dali::GestureDetector *)jarg1;
93494 }
93495
93496 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
93497     return (Dali::Gesture *)jarg1;
93498 }
93499
93500 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
93501     return (Dali::Handle *)jarg1;
93502 }
93503
93504 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
93505     return (Dali::Actor *)jarg1;
93506 }
93507
93508 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
93509     return (Dali::BaseHandle *)jarg1;
93510 }
93511
93512 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
93513     return (Dali::RefObject *)jarg1;
93514 }
93515
93516 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
93517     return (Dali::Actor *)jarg1;
93518 }
93519
93520 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
93521     return (Dali::GestureDetector *)jarg1;
93522 }
93523
93524 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
93525     return (Dali::Gesture *)jarg1;
93526 }
93527
93528 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
93529     return (Dali::GestureDetector *)jarg1;
93530 }
93531
93532 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
93533     return (Dali::Gesture *)jarg1;
93534 }
93535
93536 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
93537     return (Dali::GestureDetector *)jarg1;
93538 }
93539
93540 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
93541     return (Dali::Gesture *)jarg1;
93542 }
93543
93544 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
93545     return (Dali::BaseHandle *)jarg1;
93546 }
93547
93548 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
93549     return (Dali::Handle *)jarg1;
93550 }
93551
93552 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Animation_SWIGUpcast(Dali::Animation *jarg1) {
93553     return (Dali::BaseHandle *)jarg1;
93554 }
93555
93556 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
93557     return (Dali::Handle *)jarg1;
93558 }
93559
93560 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
93561     return (Dali::Handle *)jarg1;
93562 }
93563
93564 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
93565     return (Dali::Image *)jarg1;
93566 }
93567
93568 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
93569     return (Dali::Image *)jarg1;
93570 }
93571
93572 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
93573     return (Dali::Image *)jarg1;
93574 }
93575
93576 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
93577     return (Dali::RefObject *)jarg1;
93578 }
93579
93580 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
93581     return (Dali::Image *)jarg1;
93582 }
93583
93584 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
93585     return (Dali::Image *)jarg1;
93586 }
93587
93588 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
93589     return (Dali::ResourceImage *)jarg1;
93590 }
93591
93592 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
93593     return (Dali::Actor *)jarg1;
93594 }
93595
93596 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
93597     return (Dali::BaseHandle *)jarg1;
93598 }
93599
93600 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
93601     return (Dali::BaseHandle *)jarg1;
93602 }
93603
93604 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Window_SWIGUpcast(Dali::Window *jarg1) {
93605     return (Dali::BaseHandle *)jarg1;
93606 }
93607
93608 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Application_SWIGUpcast(Dali::Application *jarg1) {
93609     return (Dali::BaseHandle *)jarg1;
93610 }
93611
93612 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
93613     return (Dali::BaseHandle *)jarg1;
93614 }
93615
93616 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
93617     return (Dali::BaseHandle *)jarg1;
93618 }
93619
93620 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
93621     return (Dali::CustomActorImpl *)jarg1;
93622 }
93623
93624 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
93625     return (Dali::CustomActor *)jarg1;
93626 }
93627
93628 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
93629     return (Dali::BaseHandle *)jarg1;
93630 }
93631
93632 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
93633     return (Dali::Toolkit::Control *)jarg1;
93634 }
93635
93636 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
93637     return (Dali::Toolkit::Control *)jarg1;
93638 }
93639
93640 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
93641     return (Dali::Toolkit::Button *)jarg1;
93642 }
93643
93644 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
93645     return (Dali::Toolkit::Button *)jarg1;
93646 }
93647
93648 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
93649     return (Dali::Toolkit::Button *)jarg1;
93650 }
93651
93652 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
93653     return (Dali::Toolkit::Control *)jarg1;
93654 }
93655
93656 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
93657     return (Dali::Toolkit::Control *)jarg1;
93658 }
93659
93660 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
93661     return (Dali::Toolkit::Control *)jarg1;
93662 }
93663
93664 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
93665     return (Dali::Toolkit::Control *)jarg1;
93666 }
93667
93668 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
93669     return (Dali::Toolkit::Control *)jarg1;
93670 }
93671
93672 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
93673     return (Dali::RefObject *)jarg1;
93674 }
93675
93676 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
93677     return (Dali::Toolkit::Scrollable *)jarg1;
93678 }
93679
93680 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
93681     return (Dali::BaseHandle *)jarg1;
93682 }
93683
93684 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
93685     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
93686 }
93687
93688 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
93689     return (Dali::RefObject *)jarg1;
93690 }
93691
93692 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
93693     return (Dali::Toolkit::Ruler *)jarg1;
93694 }
93695
93696 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
93697     return (Dali::Toolkit::Ruler *)jarg1;
93698 }
93699
93700 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
93701     return (Dali::Toolkit::Scrollable *)jarg1;
93702 }
93703
93704 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
93705     return (Dali::Toolkit::Control *)jarg1;
93706 }
93707
93708 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextEditor_SWIGUpcast(Dali::Toolkit::TextEditor *jarg1) {
93709     return (Dali::Toolkit::Control *)jarg1;
93710 }
93711
93712 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextField_SWIGUpcast(Dali::Toolkit::TextField *jarg1) {
93713     return (Dali::Toolkit::Control *)jarg1;
93714 }
93715
93716 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
93717     return (Dali::Toolkit::Control *)jarg1;
93718 }
93719
93720 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
93721     return (Dali::BaseHandle *)jarg1;
93722 }
93723
93724 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
93725     return (Dali::BaseHandle *)jarg1;
93726 }
93727
93728 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
93729     return (Dali::Toolkit::Control *)jarg1;
93730 }
93731
93732 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
93733     return (Dali::Toolkit::Control *)jarg1;
93734 }
93735
93736 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
93737     return (Dali::Toolkit::Control *)jarg1;
93738 }
93739
93740 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
93741     return (Dali::Toolkit::Control *)jarg1;
93742 }
93743
93744 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
93745     return (Dali::Toolkit::Control *)jarg1;
93746 }
93747
93748 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
93749     return (Dali::Toolkit::Control *)jarg1;
93750 }
93751
93752 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
93753     return (Dali::Toolkit::PageTurnView *)jarg1;
93754 }
93755
93756 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
93757     return (Dali::Toolkit::PageTurnView *)jarg1;
93758 }
93759
93760 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
93761     return (Dali::Toolkit::Button *)jarg1;
93762 }
93763
93764 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
93765     return (Dali::BaseHandle *)jarg1;
93766 }
93767
93768 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
93769     return (Dali::BaseHandle *)jarg1;
93770 }
93771
93772 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
93773     return (Dali::BaseHandle *)jarg1;
93774 }
93775
93776
93777
93778
93779
93780 //////////////////////////////////////////////////
93781 //from dali-swig autogeneration (from dali_wrap.cpp)
93782
93783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfEventData__SWIG_0() {
93784   void * jresult ;
93785   Dali::ImfManager::ImfEventData *result = 0 ;
93786
93787   {
93788     try {
93789       result = (Dali::ImfManager::ImfEventData *)new Dali::ImfManager::ImfEventData();
93790     } catch (std::out_of_range& e) {
93791       {
93792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93793       };
93794     } catch (std::exception& e) {
93795       {
93796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93797       };
93798     } catch (...) {
93799       {
93800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93801       };
93802     }
93803   }
93804   jresult = (void *)result;
93805   return jresult;
93806 }
93807
93808
93809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfEventData__SWIG_1(int jarg1, char * jarg2, int jarg3, int jarg4) {
93810   void * jresult ;
93811   Dali::ImfManager::ImfEvent arg1 ;
93812   std::string *arg2 = 0 ;
93813   int arg3 ;
93814   int arg4 ;
93815   Dali::ImfManager::ImfEventData *result = 0 ;
93816
93817   arg1 = (Dali::ImfManager::ImfEvent)jarg1;
93818   if (!jarg2) {
93819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
93820     return 0;
93821   }
93822   std::string arg2_str(jarg2);
93823   arg2 = &arg2_str;
93824   arg3 = (int)jarg3;
93825   arg4 = (int)jarg4;
93826   {
93827     try {
93828       result = (Dali::ImfManager::ImfEventData *)new Dali::ImfManager::ImfEventData(arg1,(std::string const &)*arg2,arg3,arg4);
93829     } catch (std::out_of_range& e) {
93830       {
93831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93832       };
93833     } catch (std::exception& e) {
93834       {
93835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93836       };
93837     } catch (...) {
93838       {
93839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93840       };
93841     }
93842   }
93843   jresult = (void *)result;
93844
93845   //argout typemap for const std::string&
93846
93847   return jresult;
93848 }
93849
93850
93851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_predictiveString_set(void * jarg1, char * jarg2) {
93852   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
93853   std::string *arg2 = 0 ;
93854
93855   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
93856   if (!jarg2) {
93857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
93858     return ;
93859   }
93860   std::string arg2_str(jarg2);
93861   arg2 = &arg2_str;
93862   if (arg1) (arg1)->predictiveString = *arg2;
93863
93864   //argout typemap for const std::string&
93865
93866 }
93867
93868
93869 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_predictiveString_get(void * jarg1) {
93870   char * jresult ;
93871   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
93872   std::string *result = 0 ;
93873
93874   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
93875   result = (std::string *) & ((arg1)->predictiveString);
93876   jresult = SWIG_csharp_string_callback(result->c_str());
93877   return jresult;
93878 }
93879
93880
93881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_eventName_set(void * jarg1, int jarg2) {
93882   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
93883   Dali::ImfManager::ImfEvent arg2 ;
93884
93885   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
93886   arg2 = (Dali::ImfManager::ImfEvent)jarg2;
93887   if (arg1) (arg1)->eventName = arg2;
93888 }
93889
93890
93891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_eventName_get(void * jarg1) {
93892   int jresult ;
93893   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
93894   Dali::ImfManager::ImfEvent result;
93895
93896   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
93897   result = (Dali::ImfManager::ImfEvent) ((arg1)->eventName);
93898   jresult = (int)result;
93899   return jresult;
93900 }
93901
93902
93903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_cursorOffset_set(void * jarg1, int jarg2) {
93904   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
93905   int arg2 ;
93906
93907   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
93908   arg2 = (int)jarg2;
93909   if (arg1) (arg1)->cursorOffset = arg2;
93910 }
93911
93912
93913 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_cursorOffset_get(void * jarg1) {
93914   int jresult ;
93915   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
93916   int result;
93917
93918   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
93919   result = (int) ((arg1)->cursorOffset);
93920   jresult = result;
93921   return jresult;
93922 }
93923
93924
93925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_numberOfChars_set(void * jarg1, int jarg2) {
93926   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
93927   int arg2 ;
93928
93929   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
93930   arg2 = (int)jarg2;
93931   if (arg1) (arg1)->numberOfChars = arg2;
93932 }
93933
93934
93935 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_numberOfChars_get(void * jarg1) {
93936   int jresult ;
93937   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
93938   int result;
93939
93940   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
93941   result = (int) ((arg1)->numberOfChars);
93942   jresult = result;
93943   return jresult;
93944 }
93945
93946
93947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImfManager_ImfEventData(void * jarg1) {
93948   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
93949
93950   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
93951   {
93952     try {
93953       delete arg1;
93954     } catch (std::out_of_range& e) {
93955       {
93956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93957       };
93958     } catch (std::exception& e) {
93959       {
93960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93961       };
93962     } catch (...) {
93963       {
93964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93965       };
93966     }
93967   }
93968 }
93969
93970
93971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfCallbackData__SWIG_0() {
93972   void * jresult ;
93973   Dali::ImfManager::ImfCallbackData *result = 0 ;
93974
93975   {
93976     try {
93977       result = (Dali::ImfManager::ImfCallbackData *)new Dali::ImfManager::ImfCallbackData();
93978     } catch (std::out_of_range& e) {
93979       {
93980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93981       };
93982     } catch (std::exception& e) {
93983       {
93984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93985       };
93986     } catch (...) {
93987       {
93988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93989       };
93990     }
93991   }
93992   jresult = (void *)result;
93993   return jresult;
93994 }
93995
93996
93997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfCallbackData__SWIG_1(unsigned int jarg1, int jarg2, char * jarg3, unsigned int jarg4) {
93998   void * jresult ;
93999   bool arg1 ;
94000   int arg2 ;
94001   std::string *arg3 = 0 ;
94002   bool arg4 ;
94003   Dali::ImfManager::ImfCallbackData *result = 0 ;
94004
94005   arg1 = jarg1 ? true : false;
94006   arg2 = (int)jarg2;
94007   if (!jarg3) {
94008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
94009     return 0;
94010   }
94011   std::string arg3_str(jarg3);
94012   arg3 = &arg3_str;
94013   arg4 = jarg4 ? true : false;
94014   {
94015     try {
94016       result = (Dali::ImfManager::ImfCallbackData *)new Dali::ImfManager::ImfCallbackData(arg1,arg2,(std::string const &)*arg3,arg4);
94017     } catch (std::out_of_range& e) {
94018       {
94019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94020       };
94021     } catch (std::exception& e) {
94022       {
94023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94024       };
94025     } catch (...) {
94026       {
94027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94028       };
94029     }
94030   }
94031   jresult = (void *)result;
94032
94033   //argout typemap for const std::string&
94034
94035   return jresult;
94036 }
94037
94038
94039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_currentText_set(void * jarg1, char * jarg2) {
94040   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94041   std::string *arg2 = 0 ;
94042
94043   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94044   if (!jarg2) {
94045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
94046     return ;
94047   }
94048   std::string arg2_str(jarg2);
94049   arg2 = &arg2_str;
94050   if (arg1) (arg1)->currentText = *arg2;
94051
94052   //argout typemap for const std::string&
94053
94054 }
94055
94056
94057 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_currentText_get(void * jarg1) {
94058   char * jresult ;
94059   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94060   std::string *result = 0 ;
94061
94062   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94063   result = (std::string *) & ((arg1)->currentText);
94064   jresult = SWIG_csharp_string_callback(result->c_str());
94065   return jresult;
94066 }
94067
94068
94069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_cursorPosition_set(void * jarg1, int jarg2) {
94070   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94071   int arg2 ;
94072
94073   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94074   arg2 = (int)jarg2;
94075   if (arg1) (arg1)->cursorPosition = arg2;
94076 }
94077
94078
94079 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_cursorPosition_get(void * jarg1) {
94080   int jresult ;
94081   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94082   int result;
94083
94084   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94085   result = (int) ((arg1)->cursorPosition);
94086   jresult = result;
94087   return jresult;
94088 }
94089
94090
94091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_update_set(void * jarg1, unsigned int jarg2) {
94092   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94093   bool arg2 ;
94094
94095   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94096   arg2 = jarg2 ? true : false;
94097   if (arg1) (arg1)->update = arg2;
94098 }
94099
94100
94101 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_update_get(void * jarg1) {
94102   unsigned int jresult ;
94103   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94104   bool result;
94105
94106   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94107   result = (bool) ((arg1)->update);
94108   jresult = result;
94109   return jresult;
94110 }
94111
94112
94113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_preeditResetRequired_set(void * jarg1, unsigned int jarg2) {
94114   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94115   bool arg2 ;
94116
94117   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94118   arg2 = jarg2 ? true : false;
94119   if (arg1) (arg1)->preeditResetRequired = arg2;
94120 }
94121
94122
94123 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_preeditResetRequired_get(void * jarg1) {
94124   unsigned int jresult ;
94125   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94126   bool result;
94127
94128   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94129   result = (bool) ((arg1)->preeditResetRequired);
94130   jresult = result;
94131   return jresult;
94132 }
94133
94134
94135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImfManager_ImfCallbackData(void * jarg1) {
94136   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94137
94138   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94139   {
94140     try {
94141       delete arg1;
94142     } catch (std::out_of_range& e) {
94143       {
94144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94145       };
94146     } catch (std::exception& e) {
94147       {
94148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94149       };
94150     } catch (...) {
94151       {
94152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94153       };
94154     }
94155   }
94156 }
94157
94158
94159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_Get() {
94160   void * jresult ;
94161   Dali::ImfManager result;
94162
94163   {
94164     try {
94165       result = Dali::ImfManager::Get();
94166     } catch (std::out_of_range& e) {
94167       {
94168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94169       };
94170     } catch (std::exception& e) {
94171       {
94172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94173       };
94174     } catch (...) {
94175       {
94176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94177       };
94178     }
94179   }
94180   jresult = new Dali::ImfManager((const Dali::ImfManager &)result);
94181   return jresult;
94182 }
94183
94184
94185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_Activate(void * jarg1) {
94186   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94187
94188   arg1 = (Dali::ImfManager *)jarg1;
94189   {
94190     try {
94191       (arg1)->Activate();
94192     } catch (std::out_of_range& e) {
94193       {
94194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94195       };
94196     } catch (std::exception& e) {
94197       {
94198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94199       };
94200     } catch (...) {
94201       {
94202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94203       };
94204     }
94205   }
94206 }
94207
94208
94209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_Deactivate(void * jarg1) {
94210   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94211
94212   arg1 = (Dali::ImfManager *)jarg1;
94213   {
94214     try {
94215       (arg1)->Deactivate();
94216     } catch (std::out_of_range& e) {
94217       {
94218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94219       };
94220     } catch (std::exception& e) {
94221       {
94222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94223       };
94224     } catch (...) {
94225       {
94226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94227       };
94228     }
94229   }
94230 }
94231
94232
94233 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_RestoreAfterFocusLost(void * jarg1) {
94234   unsigned int jresult ;
94235   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94236   bool result;
94237
94238   arg1 = (Dali::ImfManager *)jarg1;
94239   {
94240     try {
94241       result = (bool)((Dali::ImfManager const *)arg1)->RestoreAfterFocusLost();
94242     } catch (std::out_of_range& e) {
94243       {
94244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94245       };
94246     } catch (std::exception& e) {
94247       {
94248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94249       };
94250     } catch (...) {
94251       {
94252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94253       };
94254     }
94255   }
94256   jresult = result;
94257   return jresult;
94258 }
94259
94260
94261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetRestoreAfterFocusLost(void * jarg1, unsigned int jarg2) {
94262   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94263   bool arg2 ;
94264
94265   arg1 = (Dali::ImfManager *)jarg1;
94266   arg2 = jarg2 ? true : false;
94267   {
94268     try {
94269       (arg1)->SetRestoreAfterFocusLost(arg2);
94270     } catch (std::out_of_range& e) {
94271       {
94272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94273       };
94274     } catch (std::exception& e) {
94275       {
94276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94277       };
94278     } catch (...) {
94279       {
94280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94281       };
94282     }
94283   }
94284 }
94285
94286
94287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_Reset(void * jarg1) {
94288   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94289
94290   arg1 = (Dali::ImfManager *)jarg1;
94291   {
94292     try {
94293       (arg1)->Reset();
94294     } catch (std::out_of_range& e) {
94295       {
94296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94297       };
94298     } catch (std::exception& e) {
94299       {
94300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94301       };
94302     } catch (...) {
94303       {
94304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94305       };
94306     }
94307   }
94308 }
94309
94310
94311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_NotifyCursorPosition(void * jarg1) {
94312   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94313
94314   arg1 = (Dali::ImfManager *)jarg1;
94315   {
94316     try {
94317       (arg1)->NotifyCursorPosition();
94318     } catch (std::out_of_range& e) {
94319       {
94320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94321       };
94322     } catch (std::exception& e) {
94323       {
94324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94325       };
94326     } catch (...) {
94327       {
94328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94329       };
94330     }
94331   }
94332 }
94333
94334
94335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetCursorPosition(void * jarg1, unsigned int jarg2) {
94336   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94337   unsigned int arg2 ;
94338
94339   arg1 = (Dali::ImfManager *)jarg1;
94340   arg2 = (unsigned int)jarg2;
94341   {
94342     try {
94343       (arg1)->SetCursorPosition(arg2);
94344     } catch (std::out_of_range& e) {
94345       {
94346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94347       };
94348     } catch (std::exception& e) {
94349       {
94350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94351       };
94352     } catch (...) {
94353       {
94354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94355       };
94356     }
94357   }
94358 }
94359
94360
94361 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_GetCursorPosition(void * jarg1) {
94362   unsigned int jresult ;
94363   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94364   unsigned int result;
94365
94366   arg1 = (Dali::ImfManager *)jarg1;
94367   {
94368     try {
94369       result = (unsigned int)((Dali::ImfManager const *)arg1)->GetCursorPosition();
94370     } catch (std::out_of_range& e) {
94371       {
94372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94373       };
94374     } catch (std::exception& e) {
94375       {
94376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94377       };
94378     } catch (...) {
94379       {
94380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94381       };
94382     }
94383   }
94384   jresult = result;
94385   return jresult;
94386 }
94387
94388
94389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetSurroundingText(void * jarg1, char * jarg2) {
94390   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94391   std::string *arg2 = 0 ;
94392
94393   arg1 = (Dali::ImfManager *)jarg1;
94394   if (!jarg2) {
94395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
94396     return ;
94397   }
94398   std::string arg2_str(jarg2);
94399   arg2 = &arg2_str;
94400   {
94401     try {
94402       (arg1)->SetSurroundingText((std::string const &)*arg2);
94403     } catch (std::out_of_range& e) {
94404       {
94405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94406       };
94407     } catch (std::exception& e) {
94408       {
94409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94410       };
94411     } catch (...) {
94412       {
94413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94414       };
94415     }
94416   }
94417
94418   //argout typemap for const std::string&
94419
94420 }
94421
94422
94423 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImfManager_GetSurroundingText(void * jarg1) {
94424   char * jresult ;
94425   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94426   std::string *result = 0 ;
94427
94428   arg1 = (Dali::ImfManager *)jarg1;
94429   {
94430     try {
94431       result = (std::string *) &((Dali::ImfManager const *)arg1)->GetSurroundingText();
94432     } catch (std::out_of_range& e) {
94433       {
94434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94435       };
94436     } catch (std::exception& e) {
94437       {
94438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94439       };
94440     } catch (...) {
94441       {
94442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94443       };
94444     }
94445   }
94446   jresult = SWIG_csharp_string_callback(result->c_str());
94447   return jresult;
94448 }
94449
94450
94451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_NotifyTextInputMultiLine(void * jarg1, unsigned int jarg2) {
94452   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94453   bool arg2 ;
94454
94455   arg1 = (Dali::ImfManager *)jarg1;
94456   arg2 = jarg2 ? true : false;
94457   {
94458     try {
94459       (arg1)->NotifyTextInputMultiLine(arg2);
94460     } catch (std::out_of_range& e) {
94461       {
94462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94463       };
94464     } catch (std::exception& e) {
94465       {
94466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94467       };
94468     } catch (...) {
94469       {
94470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94471       };
94472     }
94473   }
94474 }
94475
94476
94477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_GetTextDirection(void * jarg1) {
94478   int jresult ;
94479   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94480   Dali::ImfManager::TextDirection result;
94481
94482   arg1 = (Dali::ImfManager *)jarg1;
94483   {
94484     try {
94485       result = (Dali::ImfManager::TextDirection)(arg1)->GetTextDirection();
94486     } catch (std::out_of_range& e) {
94487       {
94488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94489       };
94490     } catch (std::exception& e) {
94491       {
94492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94493       };
94494     } catch (...) {
94495       {
94496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94497       };
94498     }
94499   }
94500   jresult = (int)result;
94501   return jresult;
94502 }
94503
94504
94505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_GetInputMethodArea(void * jarg1) {
94506   void * jresult ;
94507   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94508   Dali::Rect< int > result;
94509
94510   arg1 = (Dali::ImfManager *)jarg1;
94511   {
94512     try {
94513       result = (arg1)->GetInputMethodArea();
94514     } catch (std::out_of_range& e) {
94515       {
94516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94517       };
94518     } catch (std::exception& e) {
94519       {
94520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94521       };
94522     } catch (...) {
94523       {
94524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94525       };
94526     }
94527   }
94528   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
94529   return jresult;
94530 }
94531
94532
94533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ApplyOptions(void * jarg1, void * jarg2) {
94534   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94535   Dali::InputMethodOptions *arg2 = 0 ;
94536
94537   arg1 = (Dali::ImfManager *)jarg1;
94538   arg2 = (Dali::InputMethodOptions *)jarg2;
94539   if (!arg2) {
94540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InputMethodOptions const & type is null", 0);
94541     return ;
94542   }
94543   {
94544     try {
94545       (arg1)->ApplyOptions((Dali::InputMethodOptions const &)*arg2);
94546     } catch (std::out_of_range& e) {
94547       {
94548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94549       };
94550     } catch (std::exception& e) {
94551       {
94552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94553       };
94554     } catch (...) {
94555       {
94556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94557       };
94558     }
94559   }
94560 }
94561
94562
94563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetInputPanelUserData(void * jarg1, char * jarg2) {
94564   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94565   std::string *arg2 = 0 ;
94566
94567   arg1 = (Dali::ImfManager *)jarg1;
94568   if (!jarg2) {
94569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
94570     return ;
94571   }
94572   std::string arg2_str(jarg2);
94573   arg2 = &arg2_str;
94574   {
94575     try {
94576       (arg1)->SetInputPanelUserData((std::string const &)*arg2);
94577     } catch (std::out_of_range& e) {
94578       {
94579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94580       };
94581     } catch (std::exception& e) {
94582       {
94583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94584       };
94585     } catch (...) {
94586       {
94587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94588       };
94589     }
94590   }
94591
94592   //argout typemap for const std::string&
94593
94594 }
94595
94596
94597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_GetInputPanelUserData(void * jarg1, char * jarg2) {
94598   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94599   std::string *arg2 = 0 ;
94600
94601   arg1 = (Dali::ImfManager *)jarg1;
94602   if (!jarg2) {
94603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
94604     return ;
94605   }
94606   std::string arg2_str(jarg2);
94607   arg2 = &arg2_str;
94608   {
94609     try {
94610       (arg1)->GetInputPanelUserData((std::string &)*arg2);
94611     } catch (std::out_of_range& e) {
94612       {
94613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94614       };
94615     } catch (std::exception& e) {
94616       {
94617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94618       };
94619     } catch (...) {
94620       {
94621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94622       };
94623     }
94624   }
94625
94626 }
94627
94628
94629 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_GetInputPanelState(void * jarg1) {
94630   int jresult ;
94631   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94632   Dali::ImfManager::State result;
94633
94634   arg1 = (Dali::ImfManager *)jarg1;
94635   {
94636     try {
94637       result = (Dali::ImfManager::State)(arg1)->GetInputPanelState();
94638     } catch (std::out_of_range& e) {
94639       {
94640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94641       };
94642     } catch (std::exception& e) {
94643       {
94644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94645       };
94646     } catch (...) {
94647       {
94648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94649       };
94650     }
94651   }
94652   jresult = (int)result;
94653   return jresult;
94654 }
94655
94656
94657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetReturnKeyState(void * jarg1, unsigned int jarg2) {
94658   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94659   bool arg2 ;
94660
94661   arg1 = (Dali::ImfManager *)jarg1;
94662   arg2 = jarg2 ? true : false;
94663   {
94664     try {
94665       (arg1)->SetReturnKeyState(arg2);
94666     } catch (std::out_of_range& e) {
94667       {
94668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94669       };
94670     } catch (std::exception& e) {
94671       {
94672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94673       };
94674     } catch (...) {
94675       {
94676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94677       };
94678     }
94679   }
94680 }
94681
94682
94683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_AutoEnableInputPanel(void * jarg1, unsigned int jarg2) {
94684   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94685   bool arg2 ;
94686
94687   arg1 = (Dali::ImfManager *)jarg1;
94688   arg2 = jarg2 ? true : false;
94689   {
94690     try {
94691       (arg1)->AutoEnableInputPanel(arg2);
94692     } catch (std::out_of_range& e) {
94693       {
94694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94695       };
94696     } catch (std::exception& e) {
94697       {
94698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94699       };
94700     } catch (...) {
94701       {
94702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94703       };
94704     }
94705   }
94706 }
94707
94708
94709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ShowInputPanel(void * jarg1) {
94710   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94711
94712   arg1 = (Dali::ImfManager *)jarg1;
94713   {
94714     try {
94715       (arg1)->ShowInputPanel();
94716     } catch (std::out_of_range& e) {
94717       {
94718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94719       };
94720     } catch (std::exception& e) {
94721       {
94722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94723       };
94724     } catch (...) {
94725       {
94726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94727       };
94728     }
94729   }
94730 }
94731
94732
94733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_HideInputPanel(void * jarg1) {
94734   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94735
94736   arg1 = (Dali::ImfManager *)jarg1;
94737   {
94738     try {
94739       (arg1)->HideInputPanel();
94740     } catch (std::out_of_range& e) {
94741       {
94742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94743       };
94744     } catch (std::exception& e) {
94745       {
94746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94747       };
94748     } catch (...) {
94749       {
94750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94751       };
94752     }
94753   }
94754 }
94755
94756
94757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_ActivatedSignal(void * jarg1) {
94758   void * jresult ;
94759   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94760   Dali::ImfManager::ImfManagerSignalType *result = 0 ;
94761
94762   arg1 = (Dali::ImfManager *)jarg1;
94763   {
94764     try {
94765       result = (Dali::ImfManager::ImfManagerSignalType *) &(arg1)->ActivatedSignal();
94766     } catch (std::out_of_range& e) {
94767       {
94768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94769       };
94770     } catch (std::exception& e) {
94771       {
94772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94773       };
94774     } catch (...) {
94775       {
94776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94777       };
94778     }
94779   }
94780   jresult = (void *)result;
94781   return jresult;
94782 }
94783
94784
94785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_EventReceivedSignal(void * jarg1) {
94786   void * jresult ;
94787   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94788   Dali::ImfManager::ImfEventSignalType *result = 0 ;
94789
94790   arg1 = (Dali::ImfManager *)jarg1;
94791   {
94792     try {
94793       result = (Dali::ImfManager::ImfEventSignalType *) &(arg1)->EventReceivedSignal();
94794     } catch (std::out_of_range& e) {
94795       {
94796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94797       };
94798     } catch (std::exception& e) {
94799       {
94800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94801       };
94802     } catch (...) {
94803       {
94804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94805       };
94806     }
94807   }
94808   jresult = (void *)result;
94809   return jresult;
94810 }
94811
94812
94813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_StatusChangedSignal(void * jarg1) {
94814   void * jresult ;
94815   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94816   Dali::ImfManager::StatusSignalType *result = 0 ;
94817
94818   arg1 = (Dali::ImfManager *)jarg1;
94819   {
94820     try {
94821       result = (Dali::ImfManager::StatusSignalType *) &(arg1)->StatusChangedSignal();
94822     } catch (std::out_of_range& e) {
94823       {
94824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94825       };
94826     } catch (std::exception& e) {
94827       {
94828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94829       };
94830     } catch (...) {
94831       {
94832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94833       };
94834     }
94835   }
94836   jresult = (void *)result;
94837   return jresult;
94838 }
94839
94840
94841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_ResizedSignal(void * jarg1) {
94842   void * jresult ;
94843   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94844   Dali::ImfManager::VoidSignalType *result = 0 ;
94845
94846   arg1 = (Dali::ImfManager *)jarg1;
94847   {
94848     try {
94849       result = (Dali::ImfManager::VoidSignalType *) &(arg1)->ResizedSignal();
94850     } catch (std::out_of_range& e) {
94851       {
94852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94853       };
94854     } catch (std::exception& e) {
94855       {
94856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94857       };
94858     } catch (...) {
94859       {
94860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94861       };
94862     }
94863   }
94864   jresult = (void *)result;
94865   return jresult;
94866 }
94867
94868
94869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_LanguageChangedSignal(void * jarg1) {
94870   void * jresult ;
94871   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94872   Dali::ImfManager::VoidSignalType *result = 0 ;
94873
94874   arg1 = (Dali::ImfManager *)jarg1;
94875   {
94876     try {
94877       result = (Dali::ImfManager::VoidSignalType *) &(arg1)->LanguageChangedSignal();
94878     } catch (std::out_of_range& e) {
94879       {
94880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94881       };
94882     } catch (std::exception& e) {
94883       {
94884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94885       };
94886     } catch (...) {
94887       {
94888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94889       };
94890     }
94891   }
94892   jresult = (void *)result;
94893   return jresult;
94894 }
94895
94896
94897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager__SWIG_0() {
94898   void * jresult ;
94899   Dali::ImfManager *result = 0 ;
94900
94901   {
94902     try {
94903       result = (Dali::ImfManager *)new Dali::ImfManager();
94904     } catch (std::out_of_range& e) {
94905       {
94906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94907       };
94908     } catch (std::exception& e) {
94909       {
94910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94911       };
94912     } catch (...) {
94913       {
94914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94915       };
94916     }
94917   }
94918   jresult = (void *)result;
94919   return jresult;
94920 }
94921
94922
94923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImfManager(void * jarg1) {
94924   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94925
94926   arg1 = (Dali::ImfManager *)jarg1;
94927   {
94928     try {
94929       delete arg1;
94930     } catch (std::out_of_range& e) {
94931       {
94932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94933       };
94934     } catch (std::exception& e) {
94935       {
94936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94937       };
94938     } catch (...) {
94939       {
94940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94941       };
94942     }
94943   }
94944 }
94945
94946
94947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager__SWIG_1(void * jarg1) {
94948   void * jresult ;
94949   Dali::Internal::Adaptor::ImfManager *arg1 = (Dali::Internal::Adaptor::ImfManager *) 0 ;
94950   Dali::ImfManager *result = 0 ;
94951
94952   arg1 = (Dali::Internal::Adaptor::ImfManager *)jarg1;
94953   {
94954     try {
94955       result = (Dali::ImfManager *)new Dali::ImfManager(arg1);
94956     } catch (std::out_of_range& e) {
94957       {
94958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94959       };
94960     } catch (std::exception& e) {
94961       {
94962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94963       };
94964     } catch (...) {
94965       {
94966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94967       };
94968     }
94969   }
94970   jresult = (void *)result;
94971   return jresult;
94972 }
94973
94974
94975 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ImfManager_SWIGUpcast(Dali::ImfManager *jarg1) {
94976     return (Dali::BaseHandle *)jarg1;
94977 }
94978
94979
94980 //////////////////////////////////////////////////
94981 //from dali-swig autogeneration (from dali_wrap.cpp)
94982
94983
94984
94985
94986
94987
94988
94989
94990
94991
94992
94993
94994 #ifdef __cplusplus
94995 }
94996 #endif
94997