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 unsigned int SWIGSTDCALL CSharp_Dali_GetSupportedAuxiliaryHintCount(void * jarg1) {
54422   unsigned int jresult ;
54423   Dali::Window arg1 ;
54424   Dali::Window *argp1 ;
54425   unsigned int result;
54426
54427   argp1 = (Dali::Window *)jarg1;
54428   if (!argp1) {
54429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54430     return 0;
54431   }
54432   arg1 = *argp1;
54433   {
54434     try {
54435       result = (unsigned int)Dali::DevelWindow::GetSupportedAuxiliaryHintCount(arg1);
54436     } catch (std::out_of_range& e) {
54437       {
54438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54439       };
54440     } catch (std::exception& e) {
54441       {
54442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54443       };
54444     } catch (...) {
54445       {
54446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54447       };
54448     }
54449   }
54450   jresult = result;
54451   return jresult;
54452 }
54453
54454
54455 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetSupportedAuxiliaryHint(void * jarg1, unsigned int jarg2) {
54456   char * jresult ;
54457   Dali::Window arg1 ;
54458   unsigned int arg2 ;
54459   Dali::Window *argp1 ;
54460   std::string result;
54461
54462   argp1 = (Dali::Window *)jarg1;
54463   if (!argp1) {
54464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54465     return 0;
54466   }
54467   arg1 = *argp1;
54468   arg2 = (unsigned int)jarg2;
54469   {
54470     try {
54471       result = Dali::DevelWindow::GetSupportedAuxiliaryHint(arg1,arg2);
54472     } catch (std::out_of_range& e) {
54473       {
54474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54475       };
54476     } catch (std::exception& e) {
54477       {
54478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54479       };
54480     } catch (...) {
54481       {
54482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54483       };
54484     }
54485   }
54486   jresult = SWIG_csharp_string_callback((&result)->c_str());
54487   return jresult;
54488 }
54489
54490
54491 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AddAuxiliaryHint(void * jarg1, char * jarg2, char * jarg3) {
54492   unsigned int jresult ;
54493   Dali::Window arg1 ;
54494   std::string *arg2 = 0 ;
54495   std::string *arg3 = 0 ;
54496   Dali::Window *argp1 ;
54497   unsigned int result;
54498
54499   argp1 = (Dali::Window *)jarg1;
54500   if (!argp1) {
54501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54502     return 0;
54503   }
54504   arg1 = *argp1;
54505   if (!jarg2) {
54506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54507     return 0;
54508   }
54509   std::string arg2_str(jarg2);
54510   arg2 = &arg2_str;
54511   if (!jarg3) {
54512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54513     return 0;
54514   }
54515   std::string arg3_str(jarg3);
54516   arg3 = &arg3_str;
54517   {
54518     try {
54519       result = (unsigned int)Dali::DevelWindow::AddAuxiliaryHint(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
54520     } catch (std::out_of_range& e) {
54521       {
54522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54523       };
54524     } catch (std::exception& e) {
54525       {
54526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54527       };
54528     } catch (...) {
54529       {
54530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54531       };
54532     }
54533   }
54534   jresult = result;
54535
54536   //argout typemap for const std::string&
54537
54538
54539   //argout typemap for const std::string&
54540
54541   return jresult;
54542 }
54543
54544
54545 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RemoveAuxiliaryHint(void * jarg1, unsigned int jarg2) {
54546   unsigned int jresult ;
54547   Dali::Window arg1 ;
54548   unsigned int arg2 ;
54549   Dali::Window *argp1 ;
54550   bool result;
54551
54552   argp1 = (Dali::Window *)jarg1;
54553   if (!argp1) {
54554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54555     return 0;
54556   }
54557   arg1 = *argp1;
54558   arg2 = (unsigned int)jarg2;
54559   {
54560     try {
54561       result = (bool)Dali::DevelWindow::RemoveAuxiliaryHint(arg1,arg2);
54562     } catch (std::out_of_range& e) {
54563       {
54564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54565       };
54566     } catch (std::exception& e) {
54567       {
54568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54569       };
54570     } catch (...) {
54571       {
54572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54573       };
54574     }
54575   }
54576   jresult = result;
54577   return jresult;
54578 }
54579
54580
54581 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetAuxiliaryHintValue(void * jarg1, unsigned int jarg2, char * jarg3) {
54582   unsigned int jresult ;
54583   Dali::Window arg1 ;
54584   unsigned int arg2 ;
54585   std::string *arg3 = 0 ;
54586   Dali::Window *argp1 ;
54587   bool result;
54588
54589   argp1 = (Dali::Window *)jarg1;
54590   if (!argp1) {
54591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54592     return 0;
54593   }
54594   arg1 = *argp1;
54595   arg2 = (unsigned int)jarg2;
54596   if (!jarg3) {
54597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54598     return 0;
54599   }
54600   std::string arg3_str(jarg3);
54601   arg3 = &arg3_str;
54602   {
54603     try {
54604       result = (bool)Dali::DevelWindow::SetAuxiliaryHintValue(arg1,arg2,(std::string const &)*arg3);
54605     } catch (std::out_of_range& e) {
54606       {
54607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54608       };
54609     } catch (std::exception& e) {
54610       {
54611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54612       };
54613     } catch (...) {
54614       {
54615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54616       };
54617     }
54618   }
54619   jresult = result;
54620
54621   //argout typemap for const std::string&
54622
54623   return jresult;
54624 }
54625
54626
54627 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetAuxiliaryHintValue(void * jarg1, unsigned int jarg2) {
54628   char * jresult ;
54629   Dali::Window arg1 ;
54630   unsigned int arg2 ;
54631   Dali::Window *argp1 ;
54632   std::string result;
54633
54634   argp1 = (Dali::Window *)jarg1;
54635   if (!argp1) {
54636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54637     return 0;
54638   }
54639   arg1 = *argp1;
54640   arg2 = (unsigned int)jarg2;
54641   {
54642     try {
54643       result = Dali::DevelWindow::GetAuxiliaryHintValue(arg1,arg2);
54644     } catch (std::out_of_range& e) {
54645       {
54646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54647       };
54648     } catch (std::exception& e) {
54649       {
54650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54651       };
54652     } catch (...) {
54653       {
54654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54655       };
54656     }
54657   }
54658   jresult = SWIG_csharp_string_callback((&result)->c_str());
54659   return jresult;
54660 }
54661
54662
54663 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetAuxiliaryHintId(void * jarg1, char * jarg2) {
54664   unsigned int jresult ;
54665   Dali::Window arg1 ;
54666   std::string *arg2 = 0 ;
54667   Dali::Window *argp1 ;
54668   unsigned int result;
54669
54670   argp1 = (Dali::Window *)jarg1;
54671   if (!argp1) {
54672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54673     return 0;
54674   }
54675   arg1 = *argp1;
54676   if (!jarg2) {
54677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54678     return 0;
54679   }
54680   std::string arg2_str(jarg2);
54681   arg2 = &arg2_str;
54682   {
54683     try {
54684       result = (unsigned int)Dali::DevelWindow::GetAuxiliaryHintId(arg1,(std::string const &)*arg2);
54685     } catch (std::out_of_range& e) {
54686       {
54687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54688       };
54689     } catch (std::exception& e) {
54690       {
54691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54692       };
54693     } catch (...) {
54694       {
54695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54696       };
54697     }
54698   }
54699   jresult = result;
54700
54701   //argout typemap for const std::string&
54702
54703   return jresult;
54704 }
54705
54706
54707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetInputRegion(void * jarg1, void * jarg2) {
54708   Dali::Window arg1 ;
54709   Dali::Rect< int > *arg2 = 0 ;
54710   Dali::Window *argp1 ;
54711
54712   argp1 = (Dali::Window *)jarg1;
54713   if (!argp1) {
54714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54715     return ;
54716   }
54717   arg1 = *argp1;
54718   arg2 = (Dali::Rect< int > *)jarg2;
54719   if (!arg2) {
54720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
54721     return ;
54722   }
54723   {
54724     try {
54725       Dali::DevelWindow::SetInputRegion(arg1,(Dali::Rect< int > const &)*arg2);
54726     } catch (std::out_of_range& e) {
54727       {
54728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54729       };
54730     } catch (std::exception& e) {
54731       {
54732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54733       };
54734     } catch (...) {
54735       {
54736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54737       };
54738     }
54739   }
54740 }
54741
54742
54743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetType(void * jarg1, int jarg2) {
54744   Dali::Window arg1 ;
54745   Dali::DevelWindow::Type arg2 ;
54746   Dali::Window *argp1 ;
54747
54748   argp1 = (Dali::Window *)jarg1;
54749   if (!argp1) {
54750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54751     return ;
54752   }
54753   arg1 = *argp1;
54754   arg2 = (Dali::DevelWindow::Type)jarg2;
54755   {
54756     try {
54757       Dali::DevelWindow::SetType(arg1,arg2);
54758     } catch (std::out_of_range& e) {
54759       {
54760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54761       };
54762     } catch (std::exception& e) {
54763       {
54764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54765       };
54766     } catch (...) {
54767       {
54768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54769       };
54770     }
54771   }
54772 }
54773
54774
54775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetType(void * jarg1) {
54776   int jresult ;
54777   Dali::Window arg1 ;
54778   Dali::Window *argp1 ;
54779   Dali::DevelWindow::Type result;
54780
54781   argp1 = (Dali::Window *)jarg1;
54782   if (!argp1) {
54783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54784     return 0;
54785   }
54786   arg1 = *argp1;
54787   {
54788     try {
54789       result = (Dali::DevelWindow::Type)Dali::DevelWindow::GetType(arg1);
54790     } catch (std::out_of_range& e) {
54791       {
54792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54793       };
54794     } catch (std::exception& e) {
54795       {
54796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54797       };
54798     } catch (...) {
54799       {
54800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54801       };
54802     }
54803   }
54804   jresult = (int)result;
54805   return jresult;
54806 }
54807
54808
54809 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetNotificationLevel(void * jarg1, int jarg2) {
54810   unsigned int jresult ;
54811   Dali::Window arg1 ;
54812   Dali::DevelWindow::NotificationLevel::Type arg2 ;
54813   Dali::Window *argp1 ;
54814   bool result;
54815
54816   argp1 = (Dali::Window *)jarg1;
54817   if (!argp1) {
54818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54819     return 0;
54820   }
54821   arg1 = *argp1;
54822   arg2 = (Dali::DevelWindow::NotificationLevel::Type)jarg2;
54823   {
54824     try {
54825       result = (bool)Dali::DevelWindow::SetNotificationLevel(arg1,arg2);
54826     } catch (std::out_of_range& e) {
54827       {
54828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54829       };
54830     } catch (std::exception& e) {
54831       {
54832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54833       };
54834     } catch (...) {
54835       {
54836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54837       };
54838     }
54839   }
54840   jresult = result;
54841   return jresult;
54842 }
54843
54844
54845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetNotificationLevel(void * jarg1) {
54846   int jresult ;
54847   Dali::Window arg1 ;
54848   Dali::Window *argp1 ;
54849   Dali::DevelWindow::NotificationLevel::Type result;
54850
54851   argp1 = (Dali::Window *)jarg1;
54852   if (!argp1) {
54853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54854     return 0;
54855   }
54856   arg1 = *argp1;
54857   {
54858     try {
54859       result = (Dali::DevelWindow::NotificationLevel::Type)Dali::DevelWindow::GetNotificationLevel(arg1);
54860     } catch (std::out_of_range& e) {
54861       {
54862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54863       };
54864     } catch (std::exception& e) {
54865       {
54866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54867       };
54868     } catch (...) {
54869       {
54870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54871       };
54872     }
54873   }
54874   jresult = (int)result;
54875   return jresult;
54876 }
54877
54878
54879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetOpaqueState(void * jarg1, unsigned int jarg2) {
54880   Dali::Window arg1 ;
54881   bool arg2 ;
54882   Dali::Window *argp1 ;
54883
54884   argp1 = (Dali::Window *)jarg1;
54885   if (!argp1) {
54886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54887     return ;
54888   }
54889   arg1 = *argp1;
54890   arg2 = jarg2 ? true : false;
54891   {
54892     try {
54893       Dali::DevelWindow::SetOpaqueState(arg1,arg2);
54894     } catch (std::out_of_range& e) {
54895       {
54896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54897       };
54898     } catch (std::exception& e) {
54899       {
54900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54901       };
54902     } catch (...) {
54903       {
54904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54905       };
54906     }
54907   }
54908 }
54909
54910
54911 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsOpaqueState(void * jarg1) {
54912   unsigned int jresult ;
54913   Dali::Window arg1 ;
54914   Dali::Window *argp1 ;
54915   bool result;
54916
54917   argp1 = (Dali::Window *)jarg1;
54918   if (!argp1) {
54919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54920     return 0;
54921   }
54922   arg1 = *argp1;
54923   {
54924     try {
54925       result = (bool)Dali::DevelWindow::IsOpaqueState(arg1);
54926     } catch (std::out_of_range& e) {
54927       {
54928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54929       };
54930     } catch (std::exception& e) {
54931       {
54932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54933       };
54934     } catch (...) {
54935       {
54936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54937       };
54938     }
54939   }
54940   jresult = result;
54941   return jresult;
54942 }
54943
54944
54945 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetScreenMode(void * jarg1, int jarg2) {
54946   unsigned int jresult ;
54947   Dali::Window arg1 ;
54948   Dali::DevelWindow::ScreenMode::Type arg2 ;
54949   Dali::Window *argp1 ;
54950   bool result;
54951
54952   argp1 = (Dali::Window *)jarg1;
54953   if (!argp1) {
54954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54955     return 0;
54956   }
54957   arg1 = *argp1;
54958   arg2 = (Dali::DevelWindow::ScreenMode::Type)jarg2;
54959   {
54960     try {
54961       result = (bool)Dali::DevelWindow::SetScreenMode(arg1,arg2);
54962     } catch (std::out_of_range& e) {
54963       {
54964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54965       };
54966     } catch (std::exception& e) {
54967       {
54968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54969       };
54970     } catch (...) {
54971       {
54972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54973       };
54974     }
54975   }
54976   jresult = result;
54977   return jresult;
54978 }
54979
54980
54981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetScreenMode(void * jarg1) {
54982   int jresult ;
54983   Dali::Window arg1 ;
54984   Dali::Window *argp1 ;
54985   Dali::DevelWindow::ScreenMode::Type result;
54986
54987   argp1 = (Dali::Window *)jarg1;
54988   if (!argp1) {
54989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54990     return 0;
54991   }
54992   arg1 = *argp1;
54993   {
54994     try {
54995       result = (Dali::DevelWindow::ScreenMode::Type)Dali::DevelWindow::GetScreenMode(arg1);
54996     } catch (std::out_of_range& e) {
54997       {
54998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54999       };
55000     } catch (std::exception& e) {
55001       {
55002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55003       };
55004     } catch (...) {
55005       {
55006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55007       };
55008     }
55009   }
55010   jresult = (int)result;
55011   return jresult;
55012 }
55013
55014
55015 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetBrightness(void * jarg1, int jarg2) {
55016   unsigned int jresult ;
55017   Dali::Window arg1 ;
55018   int arg2 ;
55019   Dali::Window *argp1 ;
55020   bool result;
55021
55022   argp1 = (Dali::Window *)jarg1;
55023   if (!argp1) {
55024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
55025     return 0;
55026   }
55027   arg1 = *argp1;
55028   arg2 = (int)jarg2;
55029   {
55030     try {
55031       result = (bool)Dali::DevelWindow::SetBrightness(arg1,arg2);
55032     } catch (std::out_of_range& e) {
55033       {
55034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55035       };
55036     } catch (std::exception& e) {
55037       {
55038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55039       };
55040     } catch (...) {
55041       {
55042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55043       };
55044     }
55045   }
55046   jresult = result;
55047   return jresult;
55048 }
55049
55050
55051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetBrightness(void * jarg1) {
55052   int jresult ;
55053   Dali::Window arg1 ;
55054   Dali::Window *argp1 ;
55055   int result;
55056
55057   argp1 = (Dali::Window *)jarg1;
55058   if (!argp1) {
55059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
55060     return 0;
55061   }
55062   arg1 = *argp1;
55063   {
55064     try {
55065       result = (int)Dali::DevelWindow::GetBrightness(arg1);
55066     } catch (std::out_of_range& e) {
55067       {
55068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55069       };
55070     } catch (std::exception& e) {
55071       {
55072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55073       };
55074     } catch (...) {
55075       {
55076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55077       };
55078     }
55079   }
55080   jresult = result;
55081   return jresult;
55082 }
55083
55084
55085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_0() {
55086   void * jresult ;
55087   Dali::Application result;
55088
55089   {
55090     try {
55091       result = Dali::Application::New();
55092     } catch (std::out_of_range& e) {
55093       {
55094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55095       };
55096     } catch (std::exception& e) {
55097       {
55098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55099       };
55100     } catch (...) {
55101       {
55102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55103       };
55104     }
55105   }
55106   jresult = new Dali::Application((const Dali::Application &)result);
55107   return jresult;
55108 }
55109
55110
55111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_1(int jarg1) {
55112   void * jresult ;
55113   int *arg1 = (int *) 0 ;
55114   char ***arg2 ;
55115   Dali::Application result;
55116
55117   {
55118     // Todo generate argv data from the C# args
55119     char **array;         // two dimensional array
55120     int numStrings = 1;     // number of strings
55121     int stringLength = 30;      // max string length.
55122     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
55123     argV = array;
55124
55125     // allocate the string data
55126     for( int i=0; i < numStrings; i++)
55127     {
55128       array[i]=(char *)malloc( stringLength * sizeof(char *) );
55129     }
55130     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
55131
55132     strcpy( array[0], "dali-csharp-app");
55133
55134     arg1 = &argC;
55135     arg2 = &argV;
55136   }
55137   {
55138     try {
55139       result = Dali::Application::New(arg1,arg2);
55140     } catch (std::out_of_range& e) {
55141       {
55142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55143       };
55144     } catch (std::exception& e) {
55145       {
55146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55147       };
55148     } catch (...) {
55149       {
55150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55151       };
55152     }
55153   }
55154   jresult = new Dali::Application((const Dali::Application &)result);
55155   return jresult;
55156 }
55157
55158
55159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_2(int jarg1, char * jarg3) {
55160   void * jresult ;
55161   int *arg1 = (int *) 0 ;
55162   char ***arg2 ;
55163   std::string *arg3 = 0 ;
55164   Dali::Application result;
55165
55166   {
55167     // Todo generate argv data from the C# args
55168     char **array;         // two dimensional array
55169     int numStrings = 1;     // number of strings
55170     int stringLength = 30;      // max string length.
55171     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
55172     argV = array;
55173
55174     // allocate the string data
55175     for( int i=0; i < numStrings; i++)
55176     {
55177       array[i]=(char *)malloc( stringLength * sizeof(char *) );
55178     }
55179     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
55180
55181     strcpy( array[0], "dali-csharp-app");
55182
55183     arg1 = &argC;
55184     arg2 = &argV;
55185   }
55186   if (!jarg3) {
55187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55188     return 0;
55189   }
55190   std::string arg3_str(jarg3);
55191   arg3 = &arg3_str;
55192   {
55193     try {
55194       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3);
55195     } catch (std::out_of_range& e) {
55196       {
55197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55198       };
55199     } catch (std::exception& e) {
55200       {
55201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55202       };
55203     } catch (...) {
55204       {
55205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55206       };
55207     }
55208   }
55209   jresult = new Dali::Application((const Dali::Application &)result);
55210
55211   //argout typemap for const std::string&
55212
55213   return jresult;
55214 }
55215
55216
55217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_3(int jarg1, char * jarg3, int jarg4) {
55218   void * jresult ;
55219   int *arg1 = (int *) 0 ;
55220   char ***arg2 ;
55221   std::string *arg3 = 0 ;
55222   Dali::Application::WINDOW_MODE arg4 ;
55223   Dali::Application result;
55224
55225   {
55226     // Todo generate argv data from the C# args
55227     char **array;         // two dimensional array
55228     int numStrings = 1;     // number of strings
55229     int stringLength = 30;      // max string length.
55230     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
55231     argV = array;
55232
55233     // allocate the string data
55234     for( int i=0; i < numStrings; i++)
55235     {
55236       array[i]=(char *)malloc( stringLength * sizeof(char *) );
55237     }
55238     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
55239
55240     strcpy( array[0], "dali-csharp-app");
55241
55242     arg1 = &argC;
55243     arg2 = &argV;
55244   }
55245   if (!jarg3) {
55246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55247     return 0;
55248   }
55249   std::string arg3_str(jarg3);
55250   arg3 = &arg3_str;
55251   arg4 = (Dali::Application::WINDOW_MODE)jarg4;
55252   {
55253     try {
55254       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3,arg4);
55255     } catch (std::out_of_range& e) {
55256       {
55257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55258       };
55259     } catch (std::exception& e) {
55260       {
55261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55262       };
55263     } catch (...) {
55264       {
55265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55266       };
55267     }
55268   }
55269   jresult = new Dali::Application((const Dali::Application &)result);
55270
55271   //argout typemap for const std::string&
55272
55273   return jresult;
55274 }
55275
55276
55277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_0() {
55278   void * jresult ;
55279   Dali::Application *result = 0 ;
55280
55281   {
55282     try {
55283       result = (Dali::Application *)new Dali::Application();
55284     } catch (std::out_of_range& e) {
55285       {
55286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55287       };
55288     } catch (std::exception& e) {
55289       {
55290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55291       };
55292     } catch (...) {
55293       {
55294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55295       };
55296     }
55297   }
55298   jresult = (void *)result;
55299   return jresult;
55300 }
55301
55302
55303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_1(void * jarg1) {
55304   void * jresult ;
55305   Dali::Application *arg1 = 0 ;
55306   Dali::Application *result = 0 ;
55307
55308   arg1 = (Dali::Application *)jarg1;
55309   if (!arg1) {
55310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
55311     return 0;
55312   }
55313   {
55314     try {
55315       result = (Dali::Application *)new Dali::Application((Dali::Application const &)*arg1);
55316     } catch (std::out_of_range& e) {
55317       {
55318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55319       };
55320     } catch (std::exception& e) {
55321       {
55322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55323       };
55324     } catch (...) {
55325       {
55326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55327       };
55328     }
55329   }
55330   jresult = (void *)result;
55331   return jresult;
55332 }
55333
55334
55335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_Assign(void * jarg1, void * jarg2) {
55336   void * jresult ;
55337   Dali::Application *arg1 = (Dali::Application *) 0 ;
55338   Dali::Application *arg2 = 0 ;
55339   Dali::Application *result = 0 ;
55340
55341   arg1 = (Dali::Application *)jarg1;
55342   arg2 = (Dali::Application *)jarg2;
55343   if (!arg2) {
55344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
55345     return 0;
55346   }
55347   {
55348     try {
55349       result = (Dali::Application *) &(arg1)->operator =((Dali::Application const &)*arg2);
55350     } catch (std::out_of_range& e) {
55351       {
55352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55353       };
55354     } catch (std::exception& e) {
55355       {
55356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55357       };
55358     } catch (...) {
55359       {
55360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55361       };
55362     }
55363   }
55364   jresult = (void *)result;
55365   return jresult;
55366 }
55367
55368
55369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Application(void * jarg1) {
55370   Dali::Application *arg1 = (Dali::Application *) 0 ;
55371
55372   arg1 = (Dali::Application *)jarg1;
55373   {
55374     try {
55375       delete arg1;
55376     } catch (std::out_of_range& e) {
55377       {
55378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55379       };
55380     } catch (std::exception& e) {
55381       {
55382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55383       };
55384     } catch (...) {
55385       {
55386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55387       };
55388     }
55389   }
55390 }
55391
55392
55393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_0(void * jarg1) {
55394   Dali::Application *arg1 = (Dali::Application *) 0 ;
55395
55396   arg1 = (Dali::Application *)jarg1;
55397   {
55398     try {
55399       (arg1)->MainLoop();
55400     } catch (std::out_of_range& e) {
55401       {
55402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55403       };
55404     } catch (std::exception& e) {
55405       {
55406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55407       };
55408     } catch (...) {
55409       {
55410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55411       };
55412     }
55413   }
55414 }
55415
55416
55417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_1(void * jarg1, void * jarg2) {
55418   Dali::Application *arg1 = (Dali::Application *) 0 ;
55419   Configuration::ContextLoss arg2 ;
55420   Configuration::ContextLoss *argp2 ;
55421
55422   arg1 = (Dali::Application *)jarg1;
55423   argp2 = (Configuration::ContextLoss *)jarg2;
55424   if (!argp2) {
55425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Configuration::ContextLoss", 0);
55426     return ;
55427   }
55428   arg2 = *argp2;
55429   {
55430     try {
55431       (arg1)->MainLoop(arg2);
55432     } catch (std::out_of_range& e) {
55433       {
55434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55435       };
55436     } catch (std::exception& e) {
55437       {
55438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55439       };
55440     } catch (...) {
55441       {
55442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55443       };
55444     }
55445   }
55446 }
55447
55448
55449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Lower(void * jarg1) {
55450   Dali::Application *arg1 = (Dali::Application *) 0 ;
55451
55452   arg1 = (Dali::Application *)jarg1;
55453   {
55454     try {
55455       (arg1)->Lower();
55456     } catch (std::out_of_range& e) {
55457       {
55458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55459       };
55460     } catch (std::exception& e) {
55461       {
55462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55463       };
55464     } catch (...) {
55465       {
55466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55467       };
55468     }
55469   }
55470 }
55471
55472
55473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Quit(void * jarg1) {
55474   Dali::Application *arg1 = (Dali::Application *) 0 ;
55475
55476   arg1 = (Dali::Application *)jarg1;
55477   {
55478     try {
55479       (arg1)->Quit();
55480     } catch (std::out_of_range& e) {
55481       {
55482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55483       };
55484     } catch (std::exception& e) {
55485       {
55486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55487       };
55488     } catch (...) {
55489       {
55490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55491       };
55492     }
55493   }
55494 }
55495
55496
55497 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_AddIdle(void * jarg1, void * jarg2) {
55498   unsigned int jresult ;
55499   Dali::Application *arg1 = (Dali::Application *) 0 ;
55500   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
55501   bool result;
55502
55503   arg1 = (Dali::Application *)jarg1;
55504   arg2 = (Dali::CallbackBase *)jarg2;
55505   {
55506     try {
55507       result = (bool)(arg1)->AddIdle(arg2);
55508     } catch (std::out_of_range& e) {
55509       {
55510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55511       };
55512     } catch (std::exception& e) {
55513       {
55514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55515       };
55516     } catch (...) {
55517       {
55518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55519       };
55520     }
55521   }
55522   jresult = result;
55523   return jresult;
55524 }
55525
55526
55527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_GetWindow(void * jarg1) {
55528   void * jresult ;
55529   Dali::Application *arg1 = (Dali::Application *) 0 ;
55530   Dali::Window result;
55531
55532   arg1 = (Dali::Application *)jarg1;
55533   {
55534     try {
55535       result = (arg1)->GetWindow();
55536     } catch (std::out_of_range& e) {
55537       {
55538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55539       };
55540     } catch (std::exception& e) {
55541       {
55542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55543       };
55544     } catch (...) {
55545       {
55546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55547       };
55548     }
55549   }
55550   jresult = new Dali::Window((const Dali::Window &)result);
55551   return jresult;
55552 }
55553
55554
55555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_ReplaceWindow(void * jarg1, void * jarg2, char * jarg3) {
55556   Dali::Application *arg1 = (Dali::Application *) 0 ;
55557   Dali::PositionSize arg2 ;
55558   std::string *arg3 = 0 ;
55559   Dali::PositionSize *argp2 ;
55560
55561   arg1 = (Dali::Application *)jarg1;
55562   argp2 = (Dali::PositionSize *)jarg2;
55563   if (!argp2) {
55564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
55565     return ;
55566   }
55567   arg2 = *argp2;
55568   if (!jarg3) {
55569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55570     return ;
55571   }
55572   std::string arg3_str(jarg3);
55573   arg3 = &arg3_str;
55574   {
55575     try {
55576       (arg1)->ReplaceWindow(arg2,(std::string const &)*arg3);
55577     } catch (std::out_of_range& e) {
55578       {
55579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55580       };
55581     } catch (std::exception& e) {
55582       {
55583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55584       };
55585     } catch (...) {
55586       {
55587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55588       };
55589     }
55590   }
55591
55592   //argout typemap for const std::string&
55593
55594 }
55595
55596
55597 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Application_GetResourcePath() {
55598   char * jresult ;
55599   std::string result;
55600
55601   {
55602     try {
55603       result = Dali::Application::GetResourcePath();
55604     } catch (std::out_of_range& e) {
55605       {
55606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55607       };
55608     } catch (std::exception& e) {
55609       {
55610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55611       };
55612     } catch (...) {
55613       {
55614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55615       };
55616     }
55617   }
55618   jresult = SWIG_csharp_string_callback((&result)->c_str());
55619   return jresult;
55620 }
55621
55622
55623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetViewMode(void * jarg1, int jarg2) {
55624   Dali::Application *arg1 = (Dali::Application *) 0 ;
55625   Dali::ViewMode arg2 ;
55626
55627   arg1 = (Dali::Application *)jarg1;
55628   arg2 = (Dali::ViewMode)jarg2;
55629   {
55630     try {
55631       (arg1)->SetViewMode(arg2);
55632     } catch (std::out_of_range& e) {
55633       {
55634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55635       };
55636     } catch (std::exception& e) {
55637       {
55638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55639       };
55640     } catch (...) {
55641       {
55642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55643       };
55644     }
55645   }
55646 }
55647
55648
55649 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Application_GetViewMode(void * jarg1) {
55650   int jresult ;
55651   Dali::Application *arg1 = (Dali::Application *) 0 ;
55652   Dali::ViewMode result;
55653
55654   arg1 = (Dali::Application *)jarg1;
55655   {
55656     try {
55657       result = (Dali::ViewMode)((Dali::Application const *)arg1)->GetViewMode();
55658     } catch (std::out_of_range& e) {
55659       {
55660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55661       };
55662     } catch (std::exception& e) {
55663       {
55664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55665       };
55666     } catch (...) {
55667       {
55668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55669       };
55670     }
55671   }
55672   jresult = (int)result;
55673   return jresult;
55674 }
55675
55676
55677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetStereoBase(void * jarg1, float jarg2) {
55678   Dali::Application *arg1 = (Dali::Application *) 0 ;
55679   float arg2 ;
55680
55681   arg1 = (Dali::Application *)jarg1;
55682   arg2 = (float)jarg2;
55683   {
55684     try {
55685       (arg1)->SetStereoBase(arg2);
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 float SWIGSTDCALL CSharp_Dali_Application_GetStereoBase(void * jarg1) {
55704   float jresult ;
55705   Dali::Application *arg1 = (Dali::Application *) 0 ;
55706   float result;
55707
55708   arg1 = (Dali::Application *)jarg1;
55709   {
55710     try {
55711       result = (float)((Dali::Application const *)arg1)->GetStereoBase();
55712     } catch (std::out_of_range& e) {
55713       {
55714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55715       };
55716     } catch (std::exception& e) {
55717       {
55718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55719       };
55720     } catch (...) {
55721       {
55722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55723       };
55724     }
55725   }
55726   jresult = result;
55727   return jresult;
55728 }
55729
55730
55731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_InitSignal(void * jarg1) {
55732   void * jresult ;
55733   Dali::Application *arg1 = (Dali::Application *) 0 ;
55734   Dali::Application::AppSignalType *result = 0 ;
55735
55736   arg1 = (Dali::Application *)jarg1;
55737   {
55738     try {
55739       result = (Dali::Application::AppSignalType *) &(arg1)->InitSignal();
55740     } catch (std::out_of_range& e) {
55741       {
55742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55743       };
55744     } catch (std::exception& e) {
55745       {
55746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55747       };
55748     } catch (...) {
55749       {
55750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55751       };
55752     }
55753   }
55754   jresult = (void *)result;
55755   return jresult;
55756 }
55757
55758
55759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_TerminateSignal(void * jarg1) {
55760   void * jresult ;
55761   Dali::Application *arg1 = (Dali::Application *) 0 ;
55762   Dali::Application::AppSignalType *result = 0 ;
55763
55764   arg1 = (Dali::Application *)jarg1;
55765   {
55766     try {
55767       result = (Dali::Application::AppSignalType *) &(arg1)->TerminateSignal();
55768     } catch (std::out_of_range& e) {
55769       {
55770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55771       };
55772     } catch (std::exception& e) {
55773       {
55774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55775       };
55776     } catch (...) {
55777       {
55778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55779       };
55780     }
55781   }
55782   jresult = (void *)result;
55783   return jresult;
55784 }
55785
55786
55787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_PauseSignal(void * jarg1) {
55788   void * jresult ;
55789   Dali::Application *arg1 = (Dali::Application *) 0 ;
55790   Dali::Application::AppSignalType *result = 0 ;
55791
55792   arg1 = (Dali::Application *)jarg1;
55793   {
55794     try {
55795       result = (Dali::Application::AppSignalType *) &(arg1)->PauseSignal();
55796     } catch (std::out_of_range& e) {
55797       {
55798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55799       };
55800     } catch (std::exception& e) {
55801       {
55802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55803       };
55804     } catch (...) {
55805       {
55806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55807       };
55808     }
55809   }
55810   jresult = (void *)result;
55811   return jresult;
55812 }
55813
55814
55815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResumeSignal(void * jarg1) {
55816   void * jresult ;
55817   Dali::Application *arg1 = (Dali::Application *) 0 ;
55818   Dali::Application::AppSignalType *result = 0 ;
55819
55820   arg1 = (Dali::Application *)jarg1;
55821   {
55822     try {
55823       result = (Dali::Application::AppSignalType *) &(arg1)->ResumeSignal();
55824     } catch (std::out_of_range& e) {
55825       {
55826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55827       };
55828     } catch (std::exception& e) {
55829       {
55830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55831       };
55832     } catch (...) {
55833       {
55834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55835       };
55836     }
55837   }
55838   jresult = (void *)result;
55839   return jresult;
55840 }
55841
55842
55843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResetSignal(void * jarg1) {
55844   void * jresult ;
55845   Dali::Application *arg1 = (Dali::Application *) 0 ;
55846   Dali::Application::AppSignalType *result = 0 ;
55847
55848   arg1 = (Dali::Application *)jarg1;
55849   {
55850     try {
55851       result = (Dali::Application::AppSignalType *) &(arg1)->ResetSignal();
55852     } catch (std::out_of_range& e) {
55853       {
55854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55855       };
55856     } catch (std::exception& e) {
55857       {
55858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55859       };
55860     } catch (...) {
55861       {
55862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55863       };
55864     }
55865   }
55866   jresult = (void *)result;
55867   return jresult;
55868 }
55869
55870
55871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResizeSignal(void * jarg1) {
55872   void * jresult ;
55873   Dali::Application *arg1 = (Dali::Application *) 0 ;
55874   Dali::Application::AppSignalType *result = 0 ;
55875
55876   arg1 = (Dali::Application *)jarg1;
55877   {
55878     try {
55879       result = (Dali::Application::AppSignalType *) &(arg1)->ResizeSignal();
55880     } catch (std::out_of_range& e) {
55881       {
55882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55883       };
55884     } catch (std::exception& e) {
55885       {
55886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55887       };
55888     } catch (...) {
55889       {
55890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55891       };
55892     }
55893   }
55894   jresult = (void *)result;
55895   return jresult;
55896 }
55897
55898
55899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_AppControlSignal(void * jarg1) {
55900   void * jresult ;
55901   Dali::Application *arg1 = (Dali::Application *) 0 ;
55902   Dali::Application::AppControlSignalType *result = 0 ;
55903
55904   arg1 = (Dali::Application *)jarg1;
55905   {
55906     try {
55907       result = (Dali::Application::AppControlSignalType *) &(arg1)->AppControlSignal();
55908     } catch (std::out_of_range& e) {
55909       {
55910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55911       };
55912     } catch (std::exception& e) {
55913       {
55914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55915       };
55916     } catch (...) {
55917       {
55918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55919       };
55920     }
55921   }
55922   jresult = (void *)result;
55923   return jresult;
55924 }
55925
55926
55927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_LanguageChangedSignal(void * jarg1) {
55928   void * jresult ;
55929   Dali::Application *arg1 = (Dali::Application *) 0 ;
55930   Dali::Application::AppSignalType *result = 0 ;
55931
55932   arg1 = (Dali::Application *)jarg1;
55933   {
55934     try {
55935       result = (Dali::Application::AppSignalType *) &(arg1)->LanguageChangedSignal();
55936     } catch (std::out_of_range& e) {
55937       {
55938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55939       };
55940     } catch (std::exception& e) {
55941       {
55942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55943       };
55944     } catch (...) {
55945       {
55946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55947       };
55948     }
55949   }
55950   jresult = (void *)result;
55951   return jresult;
55952 }
55953
55954
55955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_RegionChangedSignal(void * jarg1) {
55956   void * jresult ;
55957   Dali::Application *arg1 = (Dali::Application *) 0 ;
55958   Dali::Application::AppSignalType *result = 0 ;
55959
55960   arg1 = (Dali::Application *)jarg1;
55961   {
55962     try {
55963       result = (Dali::Application::AppSignalType *) &(arg1)->RegionChangedSignal();
55964     } catch (std::out_of_range& e) {
55965       {
55966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55967       };
55968     } catch (std::exception& e) {
55969       {
55970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55971       };
55972     } catch (...) {
55973       {
55974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55975       };
55976     }
55977   }
55978   jresult = (void *)result;
55979   return jresult;
55980 }
55981
55982
55983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_BatteryLowSignal(void * jarg1) {
55984   void * jresult ;
55985   Dali::Application *arg1 = (Dali::Application *) 0 ;
55986   Dali::Application::AppSignalType *result = 0 ;
55987
55988   arg1 = (Dali::Application *)jarg1;
55989   {
55990     try {
55991       result = (Dali::Application::AppSignalType *) &(arg1)->BatteryLowSignal();
55992     } catch (std::out_of_range& e) {
55993       {
55994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55995       };
55996     } catch (std::exception& e) {
55997       {
55998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55999       };
56000     } catch (...) {
56001       {
56002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56003       };
56004     }
56005   }
56006   jresult = (void *)result;
56007   return jresult;
56008 }
56009
56010
56011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_MemoryLowSignal(void * jarg1) {
56012   void * jresult ;
56013   Dali::Application *arg1 = (Dali::Application *) 0 ;
56014   Dali::Application::AppSignalType *result = 0 ;
56015
56016   arg1 = (Dali::Application *)jarg1;
56017   {
56018     try {
56019       result = (Dali::Application::AppSignalType *) &(arg1)->MemoryLowSignal();
56020     } catch (std::out_of_range& e) {
56021       {
56022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56023       };
56024     } catch (std::exception& e) {
56025       {
56026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56027       };
56028     } catch (...) {
56029       {
56030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56031       };
56032     }
56033   }
56034   jresult = (void *)result;
56035   return jresult;
56036 }
56037
56038
56039 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationSignal_Empty(void * jarg1) {
56040   unsigned int jresult ;
56041   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56042   bool result;
56043
56044   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56045   {
56046     try {
56047       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Application &) > const *)arg1);
56048     } catch (std::out_of_range& e) {
56049       {
56050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56051       };
56052     } catch (std::exception& e) {
56053       {
56054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56055       };
56056     } catch (...) {
56057       {
56058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56059       };
56060     }
56061   }
56062   jresult = result;
56063   return jresult;
56064 }
56065
56066
56067 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationSignal_GetConnectionCount(void * jarg1) {
56068   unsigned long jresult ;
56069   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56070   std::size_t result;
56071
56072   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56073   {
56074     try {
56075       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &) > const *)arg1);
56076     } catch (std::out_of_range& e) {
56077       {
56078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56079       };
56080     } catch (std::exception& e) {
56081       {
56082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56083       };
56084     } catch (...) {
56085       {
56086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56087       };
56088     }
56089   }
56090   jresult = (unsigned long)result;
56091   return jresult;
56092 }
56093
56094
56095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Connect(void * jarg1, void * jarg2) {
56096   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56097   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
56098
56099   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56100   arg2 = (void (*)(Dali::Application &))jarg2;
56101   {
56102     try {
56103       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(arg1,arg2);
56104     } catch (std::out_of_range& e) {
56105       {
56106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56107       };
56108     } catch (std::exception& e) {
56109       {
56110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56111       };
56112     } catch (...) {
56113       {
56114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56115       };
56116     }
56117   }
56118 }
56119
56120
56121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Disconnect(void * jarg1, void * jarg2) {
56122   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56123   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
56124
56125   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56126   arg2 = (void (*)(Dali::Application &))jarg2;
56127   {
56128     try {
56129       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(arg1,arg2);
56130     } catch (std::out_of_range& e) {
56131       {
56132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56133       };
56134     } catch (std::exception& e) {
56135       {
56136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56137       };
56138     } catch (...) {
56139       {
56140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56141       };
56142     }
56143   }
56144 }
56145
56146
56147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Emit(void * jarg1, void * jarg2) {
56148   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56149   Dali::Application *arg2 = 0 ;
56150
56151   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56152   arg2 = (Dali::Application *)jarg2;
56153   if (!arg2) {
56154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
56155     return ;
56156   }
56157   {
56158     try {
56159       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(arg1,*arg2);
56160     } catch (std::out_of_range& e) {
56161       {
56162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56163       };
56164     } catch (std::exception& e) {
56165       {
56166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56167       };
56168     } catch (...) {
56169       {
56170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56171       };
56172     }
56173   }
56174 }
56175
56176
56177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationSignal() {
56178   void * jresult ;
56179   Dali::Signal< void (Dali::Application &) > *result = 0 ;
56180
56181   {
56182     try {
56183       result = (Dali::Signal< void (Dali::Application &) > *)new Dali::Signal< void (Dali::Application &) >();
56184     } catch (std::out_of_range& e) {
56185       {
56186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56187       };
56188     } catch (std::exception& e) {
56189       {
56190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56191       };
56192     } catch (...) {
56193       {
56194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56195       };
56196     }
56197   }
56198   jresult = (void *)result;
56199   return jresult;
56200 }
56201
56202
56203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationSignal(void * jarg1) {
56204   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56205
56206   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56207   {
56208     try {
56209       delete arg1;
56210     } catch (std::out_of_range& e) {
56211       {
56212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56213       };
56214     } catch (std::exception& e) {
56215       {
56216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56217       };
56218     } catch (...) {
56219       {
56220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56221       };
56222     }
56223   }
56224 }
56225
56226
56227 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Empty(void * jarg1) {
56228   unsigned int jresult ;
56229   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56230   bool result;
56231
56232   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56233   {
56234     try {
56235       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
56236     } catch (std::out_of_range& e) {
56237       {
56238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56239       };
56240     } catch (std::exception& e) {
56241       {
56242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56243       };
56244     } catch (...) {
56245       {
56246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56247       };
56248     }
56249   }
56250   jresult = result;
56251   return jresult;
56252 }
56253
56254
56255 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_GetConnectionCount(void * jarg1) {
56256   unsigned long jresult ;
56257   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56258   std::size_t result;
56259
56260   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56261   {
56262     try {
56263       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
56264     } catch (std::out_of_range& e) {
56265       {
56266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56267       };
56268     } catch (std::exception& e) {
56269       {
56270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56271       };
56272     } catch (...) {
56273       {
56274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56275       };
56276     }
56277   }
56278   jresult = (unsigned long)result;
56279   return jresult;
56280 }
56281
56282
56283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Connect(void * jarg1, void * jarg2) {
56284   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56285   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
56286
56287   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56288   arg2 = (void (*)(Dali::Application &,void *))jarg2;
56289   {
56290     try {
56291       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(arg1,arg2);
56292     } catch (std::out_of_range& e) {
56293       {
56294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56295       };
56296     } catch (std::exception& e) {
56297       {
56298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56299       };
56300     } catch (...) {
56301       {
56302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56303       };
56304     }
56305   }
56306 }
56307
56308
56309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Disconnect(void * jarg1, void * jarg2) {
56310   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56311   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
56312
56313   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56314   arg2 = (void (*)(Dali::Application &,void *))jarg2;
56315   {
56316     try {
56317       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(arg1,arg2);
56318     } catch (std::out_of_range& e) {
56319       {
56320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56321       };
56322     } catch (std::exception& e) {
56323       {
56324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56325       };
56326     } catch (...) {
56327       {
56328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56329       };
56330     }
56331   }
56332 }
56333
56334
56335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
56336   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56337   Dali::Application *arg2 = 0 ;
56338   void *arg3 = (void *) 0 ;
56339
56340   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56341   arg2 = (Dali::Application *)jarg2;
56342   if (!arg2) {
56343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
56344     return ;
56345   }
56346   arg3 = jarg3;
56347   {
56348     try {
56349       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(arg1,*arg2,arg3);
56350     } catch (std::out_of_range& e) {
56351       {
56352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56353       };
56354     } catch (std::exception& e) {
56355       {
56356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56357       };
56358     } catch (...) {
56359       {
56360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56361       };
56362     }
56363   }
56364 }
56365
56366
56367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationControlSignal() {
56368   void * jresult ;
56369   Dali::Signal< void (Dali::Application &,void *) > *result = 0 ;
56370
56371   {
56372     try {
56373       result = (Dali::Signal< void (Dali::Application &,void *) > *)new Dali::Signal< void (Dali::Application &,void *) >();
56374     } catch (std::out_of_range& e) {
56375       {
56376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56377       };
56378     } catch (std::exception& e) {
56379       {
56380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56381       };
56382     } catch (...) {
56383       {
56384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56385       };
56386     }
56387   }
56388   jresult = (void *)result;
56389   return jresult;
56390 }
56391
56392
56393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationControlSignal(void * jarg1) {
56394   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56395
56396   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56397   {
56398     try {
56399       delete arg1;
56400     } catch (std::out_of_range& e) {
56401       {
56402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56403       };
56404     } catch (std::exception& e) {
56405       {
56406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56407       };
56408     } catch (...) {
56409       {
56410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56411       };
56412     }
56413   }
56414 }
56415
56416
56417 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
56418   unsigned int jresult ;
56419   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56420   bool result;
56421
56422   arg1 = (Dali::Signal< bool () > *)jarg1;
56423   {
56424     try {
56425       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
56426     } catch (std::out_of_range& e) {
56427       {
56428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56429       };
56430     } catch (std::exception& e) {
56431       {
56432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56433       };
56434     } catch (...) {
56435       {
56436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56437       };
56438     }
56439   }
56440   jresult = result;
56441   return jresult;
56442 }
56443
56444
56445 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
56446   unsigned long jresult ;
56447   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56448   std::size_t result;
56449
56450   arg1 = (Dali::Signal< bool () > *)jarg1;
56451   {
56452     try {
56453       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
56454     } catch (std::out_of_range& e) {
56455       {
56456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56457       };
56458     } catch (std::exception& e) {
56459       {
56460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56461       };
56462     } catch (...) {
56463       {
56464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56465       };
56466     }
56467   }
56468   jresult = (unsigned long)result;
56469   return jresult;
56470 }
56471
56472
56473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
56474   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56475   bool (*arg2)() = (bool (*)()) 0 ;
56476
56477   arg1 = (Dali::Signal< bool () > *)jarg1;
56478   arg2 = (bool (*)())jarg2;
56479   {
56480     try {
56481       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
56482     } catch (std::out_of_range& e) {
56483       {
56484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56485       };
56486     } catch (std::exception& e) {
56487       {
56488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56489       };
56490     } catch (...) {
56491       {
56492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56493       };
56494     }
56495   }
56496 }
56497
56498
56499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
56500   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56501   bool (*arg2)() = (bool (*)()) 0 ;
56502
56503   arg1 = (Dali::Signal< bool () > *)jarg1;
56504   arg2 = (bool (*)())jarg2;
56505   {
56506     try {
56507       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
56508     } catch (std::out_of_range& e) {
56509       {
56510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56511       };
56512     } catch (std::exception& e) {
56513       {
56514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56515       };
56516     } catch (...) {
56517       {
56518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56519       };
56520     }
56521   }
56522 }
56523
56524
56525 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
56526   unsigned int jresult ;
56527   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56528   bool result;
56529
56530   arg1 = (Dali::Signal< bool () > *)jarg1;
56531   {
56532     try {
56533       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
56534     } catch (std::out_of_range& e) {
56535       {
56536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56537       };
56538     } catch (std::exception& e) {
56539       {
56540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56541       };
56542     } catch (...) {
56543       {
56544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56545       };
56546     }
56547   }
56548   jresult = result;
56549   return jresult;
56550 }
56551
56552
56553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
56554   void * jresult ;
56555   Dali::Signal< bool () > *result = 0 ;
56556
56557   {
56558     try {
56559       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
56560     } catch (std::out_of_range& e) {
56561       {
56562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56563       };
56564     } catch (std::exception& e) {
56565       {
56566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56567       };
56568     } catch (...) {
56569       {
56570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56571       };
56572     }
56573   }
56574   jresult = (void *)result;
56575   return jresult;
56576 }
56577
56578
56579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
56580   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56581
56582   arg1 = (Dali::Signal< bool () > *)jarg1;
56583   {
56584     try {
56585       delete arg1;
56586     } catch (std::out_of_range& e) {
56587       {
56588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56589       };
56590     } catch (std::exception& e) {
56591       {
56592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56593       };
56594     } catch (...) {
56595       {
56596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56597       };
56598     }
56599   }
56600 }
56601
56602
56603 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Empty(void * jarg1) {
56604   unsigned int jresult ;
56605   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56606   bool result;
56607
56608   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56609   {
56610     try {
56611       result = (bool)Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty((Dali::Signal< void (bool) > const *)arg1);
56612     } catch (std::out_of_range& e) {
56613       {
56614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56615       };
56616     } catch (std::exception& e) {
56617       {
56618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56619       };
56620     } catch (...) {
56621       {
56622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56623       };
56624     }
56625   }
56626   jresult = result;
56627   return jresult;
56628 }
56629
56630
56631 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_GetConnectionCount(void * jarg1) {
56632   unsigned long jresult ;
56633   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56634   std::size_t result;
56635
56636   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56637   {
56638     try {
56639       result = Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (bool) > const *)arg1);
56640     } catch (std::out_of_range& e) {
56641       {
56642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56643       };
56644     } catch (std::exception& e) {
56645       {
56646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56647       };
56648     } catch (...) {
56649       {
56650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56651       };
56652     }
56653   }
56654   jresult = (unsigned long)result;
56655   return jresult;
56656 }
56657
56658
56659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Connect(void * jarg1, void * jarg2) {
56660   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56661   void (*arg2)(bool) = (void (*)(bool)) 0 ;
56662
56663   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56664   arg2 = (void (*)(bool))jarg2;
56665   {
56666     try {
56667       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(arg1,arg2);
56668     } catch (std::out_of_range& e) {
56669       {
56670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56671       };
56672     } catch (std::exception& e) {
56673       {
56674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56675       };
56676     } catch (...) {
56677       {
56678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56679       };
56680     }
56681   }
56682 }
56683
56684
56685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Disconnect(void * jarg1, void * jarg2) {
56686   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56687   void (*arg2)(bool) = (void (*)(bool)) 0 ;
56688
56689   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56690   arg2 = (void (*)(bool))jarg2;
56691   {
56692     try {
56693       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(arg1,arg2);
56694     } catch (std::out_of_range& e) {
56695       {
56696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56697       };
56698     } catch (std::exception& e) {
56699       {
56700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56701       };
56702     } catch (...) {
56703       {
56704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56705       };
56706     }
56707   }
56708 }
56709
56710
56711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Emit(void * jarg1, unsigned int jarg2) {
56712   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56713   bool arg2 ;
56714
56715   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56716   arg2 = jarg2 ? true : false;
56717   {
56718     try {
56719       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(arg1,arg2);
56720     } catch (std::out_of_range& e) {
56721       {
56722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56723       };
56724     } catch (std::exception& e) {
56725       {
56726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56727       };
56728     } catch (...) {
56729       {
56730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56731       };
56732     }
56733   }
56734 }
56735
56736
56737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WindowFocusSignalType() {
56738   void * jresult ;
56739   Dali::Signal< void (bool) > *result = 0 ;
56740
56741   {
56742     try {
56743       result = (Dali::Signal< void (bool) > *)new Dali::Signal< void (bool) >();
56744     } catch (std::out_of_range& e) {
56745       {
56746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56747       };
56748     } catch (std::exception& e) {
56749       {
56750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56751       };
56752     } catch (...) {
56753       {
56754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56755       };
56756     }
56757   }
56758   jresult = (void *)result;
56759   return jresult;
56760 }
56761
56762
56763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WindowFocusSignalType(void * jarg1) {
56764   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56765
56766   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56767   {
56768     try {
56769       delete arg1;
56770     } catch (std::out_of_range& e) {
56771       {
56772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56773       };
56774     } catch (std::exception& e) {
56775       {
56776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56777       };
56778     } catch (...) {
56779       {
56780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56781       };
56782     }
56783   }
56784 }
56785
56786
56787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
56788   int jresult ;
56789   int result;
56790
56791   {
56792     try {
56793       result = (int)Dali::Toolkit::Visual::Property::TYPE;
56794     } catch (std::out_of_range& e) {
56795       {
56796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56797       };
56798     } catch (std::exception& e) {
56799       {
56800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56801       };
56802     } catch (...) {
56803       {
56804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56805       };
56806     }
56807   }
56808   jresult = (int)result;
56809   return jresult;
56810 }
56811
56812
56813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
56814   int jresult ;
56815   int result;
56816
56817   {
56818     try {
56819       result = (int)Dali::Toolkit::Visual::Property::SHADER;
56820     } catch (std::out_of_range& e) {
56821       {
56822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56823       };
56824     } catch (std::exception& e) {
56825       {
56826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56827       };
56828     } catch (...) {
56829       {
56830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56831       };
56832     }
56833   }
56834   jresult = (int)result;
56835   return jresult;
56836 }
56837
56838
56839 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
56840   int jresult ;
56841   int result;
56842
56843   {
56844     try {
56845       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
56846     } catch (std::out_of_range& e) {
56847       {
56848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56849       };
56850     } catch (std::exception& e) {
56851       {
56852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56853       };
56854     } catch (...) {
56855       {
56856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56857       };
56858     }
56859   }
56860   jresult = (int)result;
56861   return jresult;
56862 }
56863
56864
56865 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
56866   int jresult ;
56867   int result;
56868
56869   {
56870     try {
56871       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
56872     } catch (std::out_of_range& e) {
56873       {
56874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56875       };
56876     } catch (std::exception& e) {
56877       {
56878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56879       };
56880     } catch (...) {
56881       {
56882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56883       };
56884     }
56885   }
56886   jresult = (int)result;
56887   return jresult;
56888 }
56889
56890
56891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
56892   int jresult ;
56893   int result;
56894
56895   {
56896     try {
56897       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
56898     } catch (std::out_of_range& e) {
56899       {
56900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56901       };
56902     } catch (std::exception& e) {
56903       {
56904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56905       };
56906     } catch (...) {
56907       {
56908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56909       };
56910     }
56911   }
56912   jresult = (int)result;
56913   return jresult;
56914 }
56915
56916
56917 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
56918   int jresult ;
56919   int result;
56920
56921   {
56922     try {
56923       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
56924     } catch (std::out_of_range& e) {
56925       {
56926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56927       };
56928     } catch (std::exception& e) {
56929       {
56930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56931       };
56932     } catch (...) {
56933       {
56934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56935       };
56936     }
56937   }
56938   jresult = (int)result;
56939   return jresult;
56940 }
56941
56942
56943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
56944   int jresult ;
56945   int result;
56946
56947   {
56948     try {
56949       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
56950     } catch (std::out_of_range& e) {
56951       {
56952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56953       };
56954     } catch (std::exception& e) {
56955       {
56956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56957       };
56958     } catch (...) {
56959       {
56960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56961       };
56962     }
56963   }
56964   jresult = (int)result;
56965   return jresult;
56966 }
56967
56968
56969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
56970   int jresult ;
56971   int result;
56972
56973   {
56974     try {
56975       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
56976     } catch (std::out_of_range& e) {
56977       {
56978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56979       };
56980     } catch (std::exception& e) {
56981       {
56982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56983       };
56984     } catch (...) {
56985       {
56986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56987       };
56988     }
56989   }
56990   jresult = (int)result;
56991   return jresult;
56992 }
56993
56994
56995 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
56996   int jresult ;
56997   int result;
56998
56999   {
57000     try {
57001       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
57002     } catch (std::out_of_range& e) {
57003       {
57004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57005       };
57006     } catch (std::exception& e) {
57007       {
57008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57009       };
57010     } catch (...) {
57011       {
57012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57013       };
57014     }
57015   }
57016   jresult = (int)result;
57017   return jresult;
57018 }
57019
57020
57021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
57022   int jresult ;
57023   int result;
57024
57025   {
57026     try {
57027       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
57028     } catch (std::out_of_range& e) {
57029       {
57030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57031       };
57032     } catch (std::exception& e) {
57033       {
57034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57035       };
57036     } catch (...) {
57037       {
57038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57039       };
57040     }
57041   }
57042   jresult = (int)result;
57043   return jresult;
57044 }
57045
57046
57047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
57048   int jresult ;
57049   int result;
57050
57051   {
57052     try {
57053       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
57054     } catch (std::out_of_range& e) {
57055       {
57056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57057       };
57058     } catch (std::exception& e) {
57059       {
57060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57061       };
57062     } catch (...) {
57063       {
57064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57065       };
57066     }
57067   }
57068   jresult = (int)result;
57069   return jresult;
57070 }
57071
57072
57073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
57074   int jresult ;
57075   int result;
57076
57077   {
57078     try {
57079       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
57080     } catch (std::out_of_range& e) {
57081       {
57082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57083       };
57084     } catch (std::exception& e) {
57085       {
57086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57087       };
57088     } catch (...) {
57089       {
57090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57091       };
57092     }
57093   }
57094   jresult = (int)result;
57095   return jresult;
57096 }
57097
57098
57099 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
57100   int jresult ;
57101   int result;
57102
57103   {
57104     try {
57105       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
57106     } catch (std::out_of_range& e) {
57107       {
57108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57109       };
57110     } catch (std::exception& e) {
57111       {
57112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57113       };
57114     } catch (...) {
57115       {
57116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57117       };
57118     }
57119   }
57120   jresult = (int)result;
57121   return jresult;
57122 }
57123
57124
57125 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
57126   int jresult ;
57127   int result;
57128
57129   {
57130     try {
57131       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
57132     } catch (std::out_of_range& e) {
57133       {
57134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57135       };
57136     } catch (std::exception& e) {
57137       {
57138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57139       };
57140     } catch (...) {
57141       {
57142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57143       };
57144     }
57145   }
57146   jresult = (int)result;
57147   return jresult;
57148 }
57149
57150
57151 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
57152   int jresult ;
57153   int result;
57154
57155   {
57156     try {
57157       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
57158     } catch (std::out_of_range& e) {
57159       {
57160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57161       };
57162     } catch (std::exception& e) {
57163       {
57164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57165       };
57166     } catch (...) {
57167       {
57168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57169       };
57170     }
57171   }
57172   jresult = (int)result;
57173   return jresult;
57174 }
57175
57176
57177 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
57178   int jresult ;
57179   int result;
57180
57181   {
57182     try {
57183       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
57184     } catch (std::out_of_range& e) {
57185       {
57186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57187       };
57188     } catch (std::exception& e) {
57189       {
57190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57191       };
57192     } catch (...) {
57193       {
57194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57195       };
57196     }
57197   }
57198   jresult = (int)result;
57199   return jresult;
57200 }
57201
57202
57203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
57204   int jresult ;
57205   int result;
57206
57207   {
57208     try {
57209       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
57210     } catch (std::out_of_range& e) {
57211       {
57212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57213       };
57214     } catch (std::exception& e) {
57215       {
57216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57217       };
57218     } catch (...) {
57219       {
57220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57221       };
57222     }
57223   }
57224   jresult = (int)result;
57225   return jresult;
57226 }
57227
57228
57229 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
57230   int jresult ;
57231   int result;
57232
57233   {
57234     try {
57235       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
57236     } catch (std::out_of_range& e) {
57237       {
57238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57239       };
57240     } catch (std::exception& e) {
57241       {
57242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57243       };
57244     } catch (...) {
57245       {
57246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57247       };
57248     }
57249   }
57250   jresult = (int)result;
57251   return jresult;
57252 }
57253
57254
57255 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
57256   int jresult ;
57257   int result;
57258
57259   {
57260     try {
57261       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
57262     } catch (std::out_of_range& e) {
57263       {
57264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57265       };
57266     } catch (std::exception& e) {
57267       {
57268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57269       };
57270     } catch (...) {
57271       {
57272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57273       };
57274     }
57275   }
57276   jresult = (int)result;
57277   return jresult;
57278 }
57279
57280
57281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
57282   int jresult ;
57283   int result;
57284
57285   {
57286     try {
57287       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
57288     } catch (std::out_of_range& e) {
57289       {
57290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57291       };
57292     } catch (std::exception& e) {
57293       {
57294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57295       };
57296     } catch (...) {
57297       {
57298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57299       };
57300     }
57301   }
57302   jresult = (int)result;
57303   return jresult;
57304 }
57305
57306
57307 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
57308   int jresult ;
57309   int result;
57310
57311   {
57312     try {
57313       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
57314     } catch (std::out_of_range& e) {
57315       {
57316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57317       };
57318     } catch (std::exception& e) {
57319       {
57320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57321       };
57322     } catch (...) {
57323       {
57324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57325       };
57326     }
57327   }
57328   jresult = (int)result;
57329   return jresult;
57330 }
57331
57332
57333 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
57334   int jresult ;
57335   int result;
57336
57337   {
57338     try {
57339       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
57340     } catch (std::out_of_range& e) {
57341       {
57342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57343       };
57344     } catch (std::exception& e) {
57345       {
57346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57347       };
57348     } catch (...) {
57349       {
57350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57351       };
57352     }
57353   }
57354   jresult = (int)result;
57355   return jresult;
57356 }
57357
57358
57359 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
57360   int jresult ;
57361   int result;
57362
57363   {
57364     try {
57365       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
57366     } catch (std::out_of_range& e) {
57367       {
57368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57369       };
57370     } catch (std::exception& e) {
57371       {
57372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57373       };
57374     } catch (...) {
57375       {
57376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57377       };
57378     }
57379   }
57380   jresult = (int)result;
57381   return jresult;
57382 }
57383
57384
57385 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
57386   int jresult ;
57387   int result;
57388
57389   {
57390     try {
57391       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
57392     } catch (std::out_of_range& e) {
57393       {
57394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57395       };
57396     } catch (std::exception& e) {
57397       {
57398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57399       };
57400     } catch (...) {
57401       {
57402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57403       };
57404     }
57405   }
57406   jresult = (int)result;
57407   return jresult;
57408 }
57409
57410
57411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
57412   int jresult ;
57413   int result;
57414
57415   {
57416     try {
57417       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
57418     } catch (std::out_of_range& e) {
57419       {
57420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57421       };
57422     } catch (std::exception& e) {
57423       {
57424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57425       };
57426     } catch (...) {
57427       {
57428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57429       };
57430     }
57431   }
57432   jresult = (int)result;
57433   return jresult;
57434 }
57435
57436
57437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
57438   int jresult ;
57439   int result;
57440
57441   {
57442     try {
57443       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
57444     } catch (std::out_of_range& e) {
57445       {
57446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57447       };
57448     } catch (std::exception& e) {
57449       {
57450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57451       };
57452     } catch (...) {
57453       {
57454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57455       };
57456     }
57457   }
57458   jresult = (int)result;
57459   return jresult;
57460 }
57461
57462
57463 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
57464   int jresult ;
57465   int result;
57466
57467   {
57468     try {
57469       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
57470     } catch (std::out_of_range& e) {
57471       {
57472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57473       };
57474     } catch (std::exception& e) {
57475       {
57476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57477       };
57478     } catch (...) {
57479       {
57480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57481       };
57482     }
57483   }
57484   jresult = (int)result;
57485   return jresult;
57486 }
57487
57488
57489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
57490   int jresult ;
57491   int result;
57492
57493   {
57494     try {
57495       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
57496     } catch (std::out_of_range& e) {
57497       {
57498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57499       };
57500     } catch (std::exception& e) {
57501       {
57502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57503       };
57504     } catch (...) {
57505       {
57506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57507       };
57508     }
57509   }
57510   jresult = (int)result;
57511   return jresult;
57512 }
57513
57514
57515 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
57516   int jresult ;
57517   int result;
57518
57519   {
57520     try {
57521       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
57522     } catch (std::out_of_range& e) {
57523       {
57524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57525       };
57526     } catch (std::exception& e) {
57527       {
57528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57529       };
57530     } catch (...) {
57531       {
57532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57533       };
57534     }
57535   }
57536   jresult = (int)result;
57537   return jresult;
57538 }
57539
57540
57541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
57542   int jresult ;
57543   int result;
57544
57545   {
57546     try {
57547       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
57548     } catch (std::out_of_range& e) {
57549       {
57550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57551       };
57552     } catch (std::exception& e) {
57553       {
57554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57555       };
57556     } catch (...) {
57557       {
57558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57559       };
57560     }
57561   }
57562   jresult = (int)result;
57563   return jresult;
57564 }
57565
57566
57567 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
57568   int jresult ;
57569   int result;
57570
57571   {
57572     try {
57573       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
57574     } catch (std::out_of_range& e) {
57575       {
57576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57577       };
57578     } catch (std::exception& e) {
57579       {
57580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57581       };
57582     } catch (...) {
57583       {
57584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57585       };
57586     }
57587   }
57588   jresult = (int)result;
57589   return jresult;
57590 }
57591
57592
57593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
57594   int jresult ;
57595   int result;
57596
57597   {
57598     try {
57599       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
57600     } catch (std::out_of_range& e) {
57601       {
57602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57603       };
57604     } catch (std::exception& e) {
57605       {
57606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57607       };
57608     } catch (...) {
57609       {
57610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57611       };
57612     }
57613   }
57614   jresult = (int)result;
57615   return jresult;
57616 }
57617
57618
57619 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
57620   int jresult ;
57621   int result;
57622
57623   {
57624     try {
57625       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
57626     } catch (std::out_of_range& e) {
57627       {
57628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57629       };
57630     } catch (std::exception& e) {
57631       {
57632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57633       };
57634     } catch (...) {
57635       {
57636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57637       };
57638     }
57639   }
57640   jresult = (int)result;
57641   return jresult;
57642 }
57643
57644
57645 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
57646   int jresult ;
57647   int result;
57648
57649   {
57650     try {
57651       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
57652     } catch (std::out_of_range& e) {
57653       {
57654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57655       };
57656     } catch (std::exception& e) {
57657       {
57658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57659       };
57660     } catch (...) {
57661       {
57662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57663       };
57664     }
57665   }
57666   jresult = (int)result;
57667   return jresult;
57668 }
57669
57670
57671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
57672   int jresult ;
57673   int result;
57674
57675   {
57676     try {
57677       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
57678     } catch (std::out_of_range& e) {
57679       {
57680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57681       };
57682     } catch (std::exception& e) {
57683       {
57684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57685       };
57686     } catch (...) {
57687       {
57688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57689       };
57690     }
57691   }
57692   jresult = (int)result;
57693   return jresult;
57694 }
57695
57696
57697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
57698   int jresult ;
57699   int result;
57700
57701   {
57702     try {
57703       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
57704     } catch (std::out_of_range& e) {
57705       {
57706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57707       };
57708     } catch (std::exception& e) {
57709       {
57710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57711       };
57712     } catch (...) {
57713       {
57714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57715       };
57716     }
57717   }
57718   jresult = (int)result;
57719   return jresult;
57720 }
57721
57722
57723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
57724   int jresult ;
57725   int result;
57726
57727   {
57728     try {
57729       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
57730     } catch (std::out_of_range& e) {
57731       {
57732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57733       };
57734     } catch (std::exception& e) {
57735       {
57736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57737       };
57738     } catch (...) {
57739       {
57740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57741       };
57742     }
57743   }
57744   jresult = (int)result;
57745   return jresult;
57746 }
57747
57748
57749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
57750   int jresult ;
57751   int result;
57752
57753   {
57754     try {
57755       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
57756     } catch (std::out_of_range& e) {
57757       {
57758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57759       };
57760     } catch (std::exception& e) {
57761       {
57762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57763       };
57764     } catch (...) {
57765       {
57766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57767       };
57768     }
57769   }
57770   jresult = (int)result;
57771   return jresult;
57772 }
57773
57774
57775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
57776   int jresult ;
57777   int result;
57778
57779   {
57780     try {
57781       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
57782     } catch (std::out_of_range& e) {
57783       {
57784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57785       };
57786     } catch (std::exception& e) {
57787       {
57788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57789       };
57790     } catch (...) {
57791       {
57792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57793       };
57794     }
57795   }
57796   jresult = (int)result;
57797   return jresult;
57798 }
57799
57800
57801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
57802   int jresult ;
57803   int result;
57804
57805   {
57806     try {
57807       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
57808     } catch (std::out_of_range& e) {
57809       {
57810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57811       };
57812     } catch (std::exception& e) {
57813       {
57814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57815       };
57816     } catch (...) {
57817       {
57818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57819       };
57820     }
57821   }
57822   jresult = (int)result;
57823   return jresult;
57824 }
57825
57826
57827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
57828   int jresult ;
57829   int result;
57830
57831   {
57832     try {
57833       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
57834     } catch (std::out_of_range& e) {
57835       {
57836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57837       };
57838     } catch (std::exception& e) {
57839       {
57840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57841       };
57842     } catch (...) {
57843       {
57844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57845       };
57846     }
57847   }
57848   jresult = (int)result;
57849   return jresult;
57850 }
57851
57852
57853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
57854   int jresult ;
57855   int result;
57856
57857   {
57858     try {
57859       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
57860     } catch (std::out_of_range& e) {
57861       {
57862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57863       };
57864     } catch (std::exception& e) {
57865       {
57866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57867       };
57868     } catch (...) {
57869       {
57870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57871       };
57872     }
57873   }
57874   jresult = (int)result;
57875   return jresult;
57876 }
57877
57878
57879 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
57880   int jresult ;
57881   int result;
57882
57883   {
57884     try {
57885       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
57886     } catch (std::out_of_range& e) {
57887       {
57888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57889       };
57890     } catch (std::exception& e) {
57891       {
57892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57893       };
57894     } catch (...) {
57895       {
57896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57897       };
57898     }
57899   }
57900   jresult = (int)result;
57901   return jresult;
57902 }
57903
57904
57905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
57906   int jresult ;
57907   int result;
57908
57909   {
57910     try {
57911       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
57912     } catch (std::out_of_range& e) {
57913       {
57914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57915       };
57916     } catch (std::exception& e) {
57917       {
57918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57919       };
57920     } catch (...) {
57921       {
57922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57923       };
57924     }
57925   }
57926   jresult = (int)result;
57927   return jresult;
57928 }
57929
57930
57931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
57932   int jresult ;
57933   int result;
57934
57935   {
57936     try {
57937       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
57938     } catch (std::out_of_range& e) {
57939       {
57940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57941       };
57942     } catch (std::exception& e) {
57943       {
57944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57945       };
57946     } catch (...) {
57947       {
57948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57949       };
57950     }
57951   }
57952   jresult = (int)result;
57953   return jresult;
57954 }
57955
57956
57957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
57958   int jresult ;
57959   int result;
57960
57961   {
57962     try {
57963       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
57964     } catch (std::out_of_range& e) {
57965       {
57966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57967       };
57968     } catch (std::exception& e) {
57969       {
57970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57971       };
57972     } catch (...) {
57973       {
57974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57975       };
57976     }
57977   }
57978   jresult = (int)result;
57979   return jresult;
57980 }
57981
57982
57983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
57984   int jresult ;
57985   int result;
57986
57987   {
57988     try {
57989       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
57990     } catch (std::out_of_range& e) {
57991       {
57992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57993       };
57994     } catch (std::exception& e) {
57995       {
57996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57997       };
57998     } catch (...) {
57999       {
58000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58001       };
58002     }
58003   }
58004   jresult = (int)result;
58005   return jresult;
58006 }
58007
58008
58009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
58010   int jresult ;
58011   int result;
58012
58013   {
58014     try {
58015       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
58016     } catch (std::out_of_range& e) {
58017       {
58018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58019       };
58020     } catch (std::exception& e) {
58021       {
58022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58023       };
58024     } catch (...) {
58025       {
58026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58027       };
58028     }
58029   }
58030   jresult = (int)result;
58031   return jresult;
58032 }
58033
58034
58035 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
58036   int jresult ;
58037   int result;
58038
58039   {
58040     try {
58041       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
58042     } catch (std::out_of_range& e) {
58043       {
58044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58045       };
58046     } catch (std::exception& e) {
58047       {
58048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58049       };
58050     } catch (...) {
58051       {
58052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58053       };
58054     }
58055   }
58056   jresult = (int)result;
58057   return jresult;
58058 }
58059
58060
58061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
58062   int jresult ;
58063   int result;
58064
58065   {
58066     try {
58067       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
58068     } catch (std::out_of_range& e) {
58069       {
58070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58071       };
58072     } catch (std::exception& e) {
58073       {
58074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58075       };
58076     } catch (...) {
58077       {
58078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58079       };
58080     }
58081   }
58082   jresult = (int)result;
58083   return jresult;
58084 }
58085
58086
58087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
58088   int jresult ;
58089   int result;
58090
58091   {
58092     try {
58093       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
58094     } catch (std::out_of_range& e) {
58095       {
58096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58097       };
58098     } catch (std::exception& e) {
58099       {
58100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58101       };
58102     } catch (...) {
58103       {
58104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58105       };
58106     }
58107   }
58108   jresult = (int)result;
58109   return jresult;
58110 }
58111
58112
58113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
58114   int jresult ;
58115   int result;
58116
58117   {
58118     try {
58119       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
58120     } catch (std::out_of_range& e) {
58121       {
58122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58123       };
58124     } catch (std::exception& e) {
58125       {
58126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58127       };
58128     } catch (...) {
58129       {
58130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58131       };
58132     }
58133   }
58134   jresult = (int)result;
58135   return jresult;
58136 }
58137
58138
58139 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
58140   int jresult ;
58141   int result;
58142
58143   {
58144     try {
58145       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
58146     } catch (std::out_of_range& e) {
58147       {
58148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58149       };
58150     } catch (std::exception& e) {
58151       {
58152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58153       };
58154     } catch (...) {
58155       {
58156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58157       };
58158     }
58159   }
58160   jresult = (int)result;
58161   return jresult;
58162 }
58163
58164
58165 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
58166   int jresult ;
58167   int result;
58168
58169   {
58170     try {
58171       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
58172     } catch (std::out_of_range& e) {
58173       {
58174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58175       };
58176     } catch (std::exception& e) {
58177       {
58178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58179       };
58180     } catch (...) {
58181       {
58182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58183       };
58184     }
58185   }
58186   jresult = (int)result;
58187   return jresult;
58188 }
58189
58190
58191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
58192   int jresult ;
58193   int result;
58194
58195   {
58196     try {
58197       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
58198     } catch (std::out_of_range& e) {
58199       {
58200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58201       };
58202     } catch (std::exception& e) {
58203       {
58204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58205       };
58206     } catch (...) {
58207       {
58208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58209       };
58210     }
58211   }
58212   jresult = (int)result;
58213   return jresult;
58214 }
58215
58216
58217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
58218   int jresult ;
58219   int result;
58220
58221   {
58222     try {
58223       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
58224     } catch (std::out_of_range& e) {
58225       {
58226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58227       };
58228     } catch (std::exception& e) {
58229       {
58230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58231       };
58232     } catch (...) {
58233       {
58234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58235       };
58236     }
58237   }
58238   jresult = (int)result;
58239   return jresult;
58240 }
58241
58242
58243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
58244   int jresult ;
58245   int result;
58246
58247   {
58248     try {
58249       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
58250     } catch (std::out_of_range& e) {
58251       {
58252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58253       };
58254     } catch (std::exception& e) {
58255       {
58256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58257       };
58258     } catch (...) {
58259       {
58260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58261       };
58262     }
58263   }
58264   jresult = (int)result;
58265   return jresult;
58266 }
58267
58268
58269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
58270   void * jresult ;
58271   Dali::Toolkit::Builder *result = 0 ;
58272
58273   {
58274     try {
58275       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
58276     } catch (std::out_of_range& e) {
58277       {
58278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58279       };
58280     } catch (std::exception& e) {
58281       {
58282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58283       };
58284     } catch (...) {
58285       {
58286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58287       };
58288     }
58289   }
58290   jresult = (void *)result;
58291   return jresult;
58292 }
58293
58294
58295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
58296   void * jresult ;
58297   Dali::Toolkit::Builder result;
58298
58299   {
58300     try {
58301       result = Dali::Toolkit::Builder::New();
58302     } catch (std::out_of_range& e) {
58303       {
58304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58305       };
58306     } catch (std::exception& e) {
58307       {
58308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58309       };
58310     } catch (...) {
58311       {
58312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58313       };
58314     }
58315   }
58316   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
58317   return jresult;
58318 }
58319
58320
58321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
58322   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58323
58324   arg1 = (Dali::Toolkit::Builder *)jarg1;
58325   {
58326     try {
58327       delete arg1;
58328     } catch (std::out_of_range& e) {
58329       {
58330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58331       };
58332     } catch (std::exception& e) {
58333       {
58334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58335       };
58336     } catch (...) {
58337       {
58338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58339       };
58340     }
58341   }
58342 }
58343
58344
58345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
58346   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58347   std::string *arg2 = 0 ;
58348   Dali::Toolkit::Builder::UIFormat arg3 ;
58349
58350   arg1 = (Dali::Toolkit::Builder *)jarg1;
58351   if (!jarg2) {
58352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58353     return ;
58354   }
58355   std::string arg2_str(jarg2);
58356   arg2 = &arg2_str;
58357   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
58358   {
58359     try {
58360       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
58361     } catch (std::out_of_range& e) {
58362       {
58363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58364       };
58365     } catch (std::exception& e) {
58366       {
58367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58368       };
58369     } catch (...) {
58370       {
58371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58372       };
58373     }
58374   }
58375
58376   //argout typemap for const std::string&
58377
58378 }
58379
58380
58381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
58382   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58383   std::string *arg2 = 0 ;
58384
58385   arg1 = (Dali::Toolkit::Builder *)jarg1;
58386   if (!jarg2) {
58387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58388     return ;
58389   }
58390   std::string arg2_str(jarg2);
58391   arg2 = &arg2_str;
58392   {
58393     try {
58394       (arg1)->LoadFromString((std::string const &)*arg2);
58395     } catch (std::out_of_range& e) {
58396       {
58397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58398       };
58399     } catch (std::exception& e) {
58400       {
58401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58402       };
58403     } catch (...) {
58404       {
58405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58406       };
58407     }
58408   }
58409
58410   //argout typemap for const std::string&
58411
58412 }
58413
58414
58415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
58416   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58417   Dali::Property::Map *arg2 = 0 ;
58418
58419   arg1 = (Dali::Toolkit::Builder *)jarg1;
58420   arg2 = (Dali::Property::Map *)jarg2;
58421   if (!arg2) {
58422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58423     return ;
58424   }
58425   {
58426     try {
58427       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
58428     } catch (std::out_of_range& e) {
58429       {
58430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58431       };
58432     } catch (std::exception& e) {
58433       {
58434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58435       };
58436     } catch (...) {
58437       {
58438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58439       };
58440     }
58441   }
58442 }
58443
58444
58445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
58446   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58447   std::string *arg2 = 0 ;
58448   Dali::Property::Value *arg3 = 0 ;
58449
58450   arg1 = (Dali::Toolkit::Builder *)jarg1;
58451   if (!jarg2) {
58452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58453     return ;
58454   }
58455   std::string arg2_str(jarg2);
58456   arg2 = &arg2_str;
58457   arg3 = (Dali::Property::Value *)jarg3;
58458   if (!arg3) {
58459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
58460     return ;
58461   }
58462   {
58463     try {
58464       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
58465     } catch (std::out_of_range& e) {
58466       {
58467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58468       };
58469     } catch (std::exception& e) {
58470       {
58471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58472       };
58473     } catch (...) {
58474       {
58475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58476       };
58477     }
58478   }
58479
58480   //argout typemap for const std::string&
58481
58482 }
58483
58484
58485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
58486   void * jresult ;
58487   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58488   Dali::Property::Map *result = 0 ;
58489
58490   arg1 = (Dali::Toolkit::Builder *)jarg1;
58491   {
58492     try {
58493       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
58494     } catch (std::out_of_range& e) {
58495       {
58496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58497       };
58498     } catch (std::exception& e) {
58499       {
58500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58501       };
58502     } catch (...) {
58503       {
58504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58505       };
58506     }
58507   }
58508   jresult = (void *)result;
58509   return jresult;
58510 }
58511
58512
58513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
58514   void * jresult ;
58515   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58516   std::string *arg2 = 0 ;
58517   Dali::Property::Value *result = 0 ;
58518
58519   arg1 = (Dali::Toolkit::Builder *)jarg1;
58520   if (!jarg2) {
58521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58522     return 0;
58523   }
58524   std::string arg2_str(jarg2);
58525   arg2 = &arg2_str;
58526   {
58527     try {
58528       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
58529     } catch (std::out_of_range& e) {
58530       {
58531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58532       };
58533     } catch (std::exception& e) {
58534       {
58535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58536       };
58537     } catch (...) {
58538       {
58539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58540       };
58541     }
58542   }
58543   jresult = (void *)result;
58544
58545   //argout typemap for const std::string&
58546
58547   return jresult;
58548 }
58549
58550
58551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
58552   void * jresult ;
58553   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58554   std::string *arg2 = 0 ;
58555   Dali::Animation result;
58556
58557   arg1 = (Dali::Toolkit::Builder *)jarg1;
58558   if (!jarg2) {
58559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58560     return 0;
58561   }
58562   std::string arg2_str(jarg2);
58563   arg2 = &arg2_str;
58564   {
58565     try {
58566       result = (arg1)->CreateAnimation((std::string const &)*arg2);
58567     } catch (std::out_of_range& e) {
58568       {
58569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58570       };
58571     } catch (std::exception& e) {
58572       {
58573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58574       };
58575     } catch (...) {
58576       {
58577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58578       };
58579     }
58580   }
58581   jresult = new Dali::Animation((const Dali::Animation &)result);
58582
58583   //argout typemap for const std::string&
58584
58585   return jresult;
58586 }
58587
58588
58589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58590   void * jresult ;
58591   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58592   std::string *arg2 = 0 ;
58593   Dali::Property::Map *arg3 = 0 ;
58594   Dali::Animation result;
58595
58596   arg1 = (Dali::Toolkit::Builder *)jarg1;
58597   if (!jarg2) {
58598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58599     return 0;
58600   }
58601   std::string arg2_str(jarg2);
58602   arg2 = &arg2_str;
58603   arg3 = (Dali::Property::Map *)jarg3;
58604   if (!arg3) {
58605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58606     return 0;
58607   }
58608   {
58609     try {
58610       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
58611     } catch (std::out_of_range& e) {
58612       {
58613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58614       };
58615     } catch (std::exception& e) {
58616       {
58617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58618       };
58619     } catch (...) {
58620       {
58621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58622       };
58623     }
58624   }
58625   jresult = new Dali::Animation((const Dali::Animation &)result);
58626
58627   //argout typemap for const std::string&
58628
58629   return jresult;
58630 }
58631
58632
58633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
58634   void * jresult ;
58635   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58636   std::string *arg2 = 0 ;
58637   Dali::Actor arg3 ;
58638   Dali::Actor *argp3 ;
58639   Dali::Animation result;
58640
58641   arg1 = (Dali::Toolkit::Builder *)jarg1;
58642   if (!jarg2) {
58643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58644     return 0;
58645   }
58646   std::string arg2_str(jarg2);
58647   arg2 = &arg2_str;
58648   argp3 = (Dali::Actor *)jarg3;
58649   if (!argp3) {
58650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58651     return 0;
58652   }
58653   arg3 = *argp3;
58654   {
58655     try {
58656       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
58657     } catch (std::out_of_range& e) {
58658       {
58659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58660       };
58661     } catch (std::exception& e) {
58662       {
58663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58664       };
58665     } catch (...) {
58666       {
58667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58668       };
58669     }
58670   }
58671   jresult = new Dali::Animation((const Dali::Animation &)result);
58672
58673   //argout typemap for const std::string&
58674
58675   return jresult;
58676 }
58677
58678
58679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
58680   void * jresult ;
58681   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58682   std::string *arg2 = 0 ;
58683   Dali::Property::Map *arg3 = 0 ;
58684   Dali::Actor arg4 ;
58685   Dali::Actor *argp4 ;
58686   Dali::Animation result;
58687
58688   arg1 = (Dali::Toolkit::Builder *)jarg1;
58689   if (!jarg2) {
58690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58691     return 0;
58692   }
58693   std::string arg2_str(jarg2);
58694   arg2 = &arg2_str;
58695   arg3 = (Dali::Property::Map *)jarg3;
58696   if (!arg3) {
58697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58698     return 0;
58699   }
58700   argp4 = (Dali::Actor *)jarg4;
58701   if (!argp4) {
58702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58703     return 0;
58704   }
58705   arg4 = *argp4;
58706   {
58707     try {
58708       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
58709     } catch (std::out_of_range& e) {
58710       {
58711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58712       };
58713     } catch (std::exception& e) {
58714       {
58715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58716       };
58717     } catch (...) {
58718       {
58719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58720       };
58721     }
58722   }
58723   jresult = new Dali::Animation((const Dali::Animation &)result);
58724
58725   //argout typemap for const std::string&
58726
58727   return jresult;
58728 }
58729
58730
58731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
58732   void * jresult ;
58733   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58734   std::string *arg2 = 0 ;
58735   Dali::BaseHandle result;
58736
58737   arg1 = (Dali::Toolkit::Builder *)jarg1;
58738   if (!jarg2) {
58739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58740     return 0;
58741   }
58742   std::string arg2_str(jarg2);
58743   arg2 = &arg2_str;
58744   {
58745     try {
58746       result = (arg1)->Create((std::string const &)*arg2);
58747     } catch (std::out_of_range& e) {
58748       {
58749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58750       };
58751     } catch (std::exception& e) {
58752       {
58753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58754       };
58755     } catch (...) {
58756       {
58757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58758       };
58759     }
58760   }
58761   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58762
58763   //argout typemap for const std::string&
58764
58765   return jresult;
58766 }
58767
58768
58769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58770   void * jresult ;
58771   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58772   std::string *arg2 = 0 ;
58773   Dali::Property::Map *arg3 = 0 ;
58774   Dali::BaseHandle result;
58775
58776   arg1 = (Dali::Toolkit::Builder *)jarg1;
58777   if (!jarg2) {
58778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58779     return 0;
58780   }
58781   std::string arg2_str(jarg2);
58782   arg2 = &arg2_str;
58783   arg3 = (Dali::Property::Map *)jarg3;
58784   if (!arg3) {
58785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58786     return 0;
58787   }
58788   {
58789     try {
58790       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
58791     } catch (std::out_of_range& e) {
58792       {
58793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58794       };
58795     } catch (std::exception& e) {
58796       {
58797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58798       };
58799     } catch (...) {
58800       {
58801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58802       };
58803     }
58804   }
58805   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58806
58807   //argout typemap for const std::string&
58808
58809   return jresult;
58810 }
58811
58812
58813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
58814   void * jresult ;
58815   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58816   std::string *arg2 = 0 ;
58817   Dali::BaseHandle result;
58818
58819   arg1 = (Dali::Toolkit::Builder *)jarg1;
58820   if (!jarg2) {
58821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58822     return 0;
58823   }
58824   std::string arg2_str(jarg2);
58825   arg2 = &arg2_str;
58826   {
58827     try {
58828       result = (arg1)->CreateFromJson((std::string const &)*arg2);
58829     } catch (std::out_of_range& e) {
58830       {
58831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58832       };
58833     } catch (std::exception& e) {
58834       {
58835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58836       };
58837     } catch (...) {
58838       {
58839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58840       };
58841     }
58842   }
58843   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58844
58845   //argout typemap for const std::string&
58846
58847   return jresult;
58848 }
58849
58850
58851 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
58852   unsigned int jresult ;
58853   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58854   std::string *arg2 = 0 ;
58855   Dali::Handle *arg3 = 0 ;
58856   bool result;
58857
58858   arg1 = (Dali::Toolkit::Builder *)jarg1;
58859   if (!jarg2) {
58860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58861     return 0;
58862   }
58863   std::string arg2_str(jarg2);
58864   arg2 = &arg2_str;
58865   arg3 = (Dali::Handle *)jarg3;
58866   if (!arg3) {
58867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
58868     return 0;
58869   }
58870   {
58871     try {
58872       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
58873     } catch (std::out_of_range& e) {
58874       {
58875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58876       };
58877     } catch (std::exception& e) {
58878       {
58879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58880       };
58881     } catch (...) {
58882       {
58883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58884       };
58885     }
58886   }
58887   jresult = result;
58888
58889   //argout typemap for const std::string&
58890
58891   return jresult;
58892 }
58893
58894
58895 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
58896   unsigned int jresult ;
58897   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58898   Dali::Handle *arg2 = 0 ;
58899   std::string *arg3 = 0 ;
58900   bool result;
58901
58902   arg1 = (Dali::Toolkit::Builder *)jarg1;
58903   arg2 = (Dali::Handle *)jarg2;
58904   if (!arg2) {
58905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
58906     return 0;
58907   }
58908   if (!jarg3) {
58909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58910     return 0;
58911   }
58912   std::string arg3_str(jarg3);
58913   arg3 = &arg3_str;
58914   {
58915     try {
58916       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
58917     } catch (std::out_of_range& e) {
58918       {
58919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58920       };
58921     } catch (std::exception& e) {
58922       {
58923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58924       };
58925     } catch (...) {
58926       {
58927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58928       };
58929     }
58930   }
58931   jresult = result;
58932
58933   //argout typemap for const std::string&
58934
58935   return jresult;
58936 }
58937
58938
58939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
58940   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58941   Dali::Actor arg2 ;
58942   Dali::Actor *argp2 ;
58943
58944   arg1 = (Dali::Toolkit::Builder *)jarg1;
58945   argp2 = (Dali::Actor *)jarg2;
58946   if (!argp2) {
58947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58948     return ;
58949   }
58950   arg2 = *argp2;
58951   {
58952     try {
58953       (arg1)->AddActors(arg2);
58954     } catch (std::out_of_range& e) {
58955       {
58956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58957       };
58958     } catch (std::exception& e) {
58959       {
58960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58961       };
58962     } catch (...) {
58963       {
58964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58965       };
58966     }
58967   }
58968 }
58969
58970
58971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58972   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58973   std::string *arg2 = 0 ;
58974   Dali::Actor arg3 ;
58975   Dali::Actor *argp3 ;
58976
58977   arg1 = (Dali::Toolkit::Builder *)jarg1;
58978   if (!jarg2) {
58979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58980     return ;
58981   }
58982   std::string arg2_str(jarg2);
58983   arg2 = &arg2_str;
58984   argp3 = (Dali::Actor *)jarg3;
58985   if (!argp3) {
58986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58987     return ;
58988   }
58989   arg3 = *argp3;
58990   {
58991     try {
58992       (arg1)->AddActors((std::string const &)*arg2,arg3);
58993     } catch (std::out_of_range& e) {
58994       {
58995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58996       };
58997     } catch (std::exception& e) {
58998       {
58999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59000       };
59001     } catch (...) {
59002       {
59003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59004       };
59005     }
59006   }
59007
59008   //argout typemap for const std::string&
59009
59010 }
59011
59012
59013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
59014   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59015   std::string *arg2 = 0 ;
59016
59017   arg1 = (Dali::Toolkit::Builder *)jarg1;
59018   if (!jarg2) {
59019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59020     return ;
59021   }
59022   std::string arg2_str(jarg2);
59023   arg2 = &arg2_str;
59024   {
59025     try {
59026       (arg1)->CreateRenderTask((std::string const &)*arg2);
59027     } catch (std::out_of_range& e) {
59028       {
59029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59030       };
59031     } catch (std::exception& e) {
59032       {
59033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59034       };
59035     } catch (...) {
59036       {
59037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59038       };
59039     }
59040   }
59041
59042   //argout typemap for const std::string&
59043
59044 }
59045
59046
59047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
59048   void * jresult ;
59049   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59050   std::string *arg2 = 0 ;
59051   Dali::FrameBufferImage result;
59052
59053   arg1 = (Dali::Toolkit::Builder *)jarg1;
59054   if (!jarg2) {
59055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59056     return 0;
59057   }
59058   std::string arg2_str(jarg2);
59059   arg2 = &arg2_str;
59060   {
59061     try {
59062       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
59063     } catch (std::out_of_range& e) {
59064       {
59065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59066       };
59067     } catch (std::exception& e) {
59068       {
59069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59070       };
59071     } catch (...) {
59072       {
59073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59074       };
59075     }
59076   }
59077   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
59078
59079   //argout typemap for const std::string&
59080
59081   return jresult;
59082 }
59083
59084
59085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
59086   void * jresult ;
59087   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59088   std::string *arg2 = 0 ;
59089   Dali::Path result;
59090
59091   arg1 = (Dali::Toolkit::Builder *)jarg1;
59092   if (!jarg2) {
59093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59094     return 0;
59095   }
59096   std::string arg2_str(jarg2);
59097   arg2 = &arg2_str;
59098   {
59099     try {
59100       result = (arg1)->GetPath((std::string const &)*arg2);
59101     } catch (std::out_of_range& e) {
59102       {
59103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59104       };
59105     } catch (std::exception& e) {
59106       {
59107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59108       };
59109     } catch (...) {
59110       {
59111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59112       };
59113     }
59114   }
59115   jresult = new Dali::Path((const Dali::Path &)result);
59116
59117   //argout typemap for const std::string&
59118
59119   return jresult;
59120 }
59121
59122
59123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
59124   void * jresult ;
59125   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59126   std::string *arg2 = 0 ;
59127   Dali::PathConstrainer result;
59128
59129   arg1 = (Dali::Toolkit::Builder *)jarg1;
59130   if (!jarg2) {
59131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59132     return 0;
59133   }
59134   std::string arg2_str(jarg2);
59135   arg2 = &arg2_str;
59136   {
59137     try {
59138       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
59139     } catch (std::out_of_range& e) {
59140       {
59141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59142       };
59143     } catch (std::exception& e) {
59144       {
59145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59146       };
59147     } catch (...) {
59148       {
59149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59150       };
59151     }
59152   }
59153   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
59154
59155   //argout typemap for const std::string&
59156
59157   return jresult;
59158 }
59159
59160
59161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
59162   void * jresult ;
59163   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59164   std::string *arg2 = 0 ;
59165   Dali::LinearConstrainer result;
59166
59167   arg1 = (Dali::Toolkit::Builder *)jarg1;
59168   if (!jarg2) {
59169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59170     return 0;
59171   }
59172   std::string arg2_str(jarg2);
59173   arg2 = &arg2_str;
59174   {
59175     try {
59176       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
59177     } catch (std::out_of_range& e) {
59178       {
59179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59180       };
59181     } catch (std::exception& e) {
59182       {
59183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59184       };
59185     } catch (...) {
59186       {
59187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59188       };
59189     }
59190   }
59191   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
59192
59193   //argout typemap for const std::string&
59194
59195   return jresult;
59196 }
59197
59198
59199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
59200   void * jresult ;
59201   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59202   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
59203
59204   arg1 = (Dali::Toolkit::Builder *)jarg1;
59205   {
59206     try {
59207       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
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 = (void *)result;
59223   return jresult;
59224 }
59225
59226
59227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
59228   void * jresult ;
59229   Dali::Toolkit::TransitionData *result = 0 ;
59230
59231   {
59232     try {
59233       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
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 = (void *)result;
59249   return jresult;
59250 }
59251
59252
59253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
59254   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59255
59256   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59257   {
59258     try {
59259       delete arg1;
59260     } catch (std::out_of_range& e) {
59261       {
59262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59263       };
59264     } catch (std::exception& e) {
59265       {
59266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59267       };
59268     } catch (...) {
59269       {
59270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59271       };
59272     }
59273   }
59274 }
59275
59276
59277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
59278   void * jresult ;
59279   Dali::Property::Map *arg1 = 0 ;
59280   Dali::Toolkit::TransitionData result;
59281
59282   arg1 = (Dali::Property::Map *)jarg1;
59283   if (!arg1) {
59284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59285     return 0;
59286   }
59287   {
59288     try {
59289       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
59290     } catch (std::out_of_range& e) {
59291       {
59292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59293       };
59294     } catch (std::exception& e) {
59295       {
59296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59297       };
59298     } catch (...) {
59299       {
59300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59301       };
59302     }
59303   }
59304   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
59305   return jresult;
59306 }
59307
59308
59309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
59310   void * jresult ;
59311   Dali::Property::Array *arg1 = 0 ;
59312   Dali::Toolkit::TransitionData result;
59313
59314   arg1 = (Dali::Property::Array *)jarg1;
59315   if (!arg1) {
59316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
59317     return 0;
59318   }
59319   {
59320     try {
59321       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
59322     } catch (std::out_of_range& e) {
59323       {
59324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59325       };
59326     } catch (std::exception& e) {
59327       {
59328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59329       };
59330     } catch (...) {
59331       {
59332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59333       };
59334     }
59335   }
59336   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
59337   return jresult;
59338 }
59339
59340
59341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
59342   void * jresult ;
59343   Dali::BaseHandle arg1 ;
59344   Dali::BaseHandle *argp1 ;
59345   Dali::Toolkit::TransitionData result;
59346
59347   argp1 = (Dali::BaseHandle *)jarg1;
59348   if (!argp1) {
59349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
59350     return 0;
59351   }
59352   arg1 = *argp1;
59353   {
59354     try {
59355       result = Dali::Toolkit::TransitionData::DownCast(arg1);
59356     } catch (std::out_of_range& e) {
59357       {
59358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59359       };
59360     } catch (std::exception& e) {
59361       {
59362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59363       };
59364     } catch (...) {
59365       {
59366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59367       };
59368     }
59369   }
59370   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
59371   return jresult;
59372 }
59373
59374
59375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
59376   void * jresult ;
59377   Dali::Toolkit::TransitionData *arg1 = 0 ;
59378   Dali::Toolkit::TransitionData *result = 0 ;
59379
59380   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59381   if (!arg1) {
59382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
59383     return 0;
59384   }
59385   {
59386     try {
59387       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
59388     } catch (std::out_of_range& e) {
59389       {
59390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59391       };
59392     } catch (std::exception& e) {
59393       {
59394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59395       };
59396     } catch (...) {
59397       {
59398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59399       };
59400     }
59401   }
59402   jresult = (void *)result;
59403   return jresult;
59404 }
59405
59406
59407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
59408   void * jresult ;
59409   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59410   Dali::Toolkit::TransitionData *arg2 = 0 ;
59411   Dali::Toolkit::TransitionData *result = 0 ;
59412
59413   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59414   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
59415   if (!arg2) {
59416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
59417     return 0;
59418   }
59419   {
59420     try {
59421       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
59422     } catch (std::out_of_range& e) {
59423       {
59424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59425       };
59426     } catch (std::exception& e) {
59427       {
59428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59429       };
59430     } catch (...) {
59431       {
59432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59433       };
59434     }
59435   }
59436   jresult = (void *)result;
59437   return jresult;
59438 }
59439
59440
59441 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
59442   unsigned long jresult ;
59443   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59444   size_t result;
59445
59446   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59447   {
59448     try {
59449       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
59450     } catch (std::out_of_range& e) {
59451       {
59452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59453       };
59454     } catch (std::exception& e) {
59455       {
59456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59457       };
59458     } catch (...) {
59459       {
59460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59461       };
59462     }
59463   }
59464   jresult = (unsigned long)result;
59465   return jresult;
59466 }
59467
59468
59469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
59470   void * jresult ;
59471   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59472   size_t arg2 ;
59473   Dali::Property::Map result;
59474
59475   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59476   arg2 = (size_t)jarg2;
59477   {
59478     try {
59479       result = (arg1)->GetAnimatorAt(arg2);
59480     } catch (std::out_of_range& e) {
59481       {
59482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59483       };
59484     } catch (std::exception& e) {
59485       {
59486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59487       };
59488     } catch (...) {
59489       {
59490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59491       };
59492     }
59493   }
59494   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
59495   return jresult;
59496 }
59497
59498
59499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_2(void * jarg1) {
59500   void * jresult ;
59501   Dali::Toolkit::Internal::TransitionData *arg1 = (Dali::Toolkit::Internal::TransitionData *) 0 ;
59502   Dali::Toolkit::TransitionData *result = 0 ;
59503
59504   arg1 = (Dali::Toolkit::Internal::TransitionData *)jarg1;
59505   {
59506     try {
59507       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData(arg1);
59508     } catch (std::out_of_range& e) {
59509       {
59510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59511       };
59512     } catch (std::exception& e) {
59513       {
59514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59515       };
59516     } catch (...) {
59517       {
59518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59519       };
59520     }
59521   }
59522   jresult = (void *)result;
59523   return jresult;
59524 }
59525
59526
59527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
59528   int jresult ;
59529   int result;
59530
59531   {
59532     try {
59533       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
59534     } catch (std::out_of_range& e) {
59535       {
59536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59537       };
59538     } catch (std::exception& e) {
59539       {
59540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59541       };
59542     } catch (...) {
59543       {
59544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59545       };
59546     }
59547   }
59548   jresult = (int)result;
59549   return jresult;
59550 }
59551
59552
59553 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
59554   int jresult ;
59555   int result;
59556
59557   {
59558     try {
59559       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
59560     } catch (std::out_of_range& e) {
59561       {
59562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59563       };
59564     } catch (std::exception& e) {
59565       {
59566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59567       };
59568     } catch (...) {
59569       {
59570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59571       };
59572     }
59573   }
59574   jresult = (int)result;
59575   return jresult;
59576 }
59577
59578
59579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
59580   int jresult ;
59581   int result;
59582
59583   {
59584     try {
59585       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
59586     } catch (std::out_of_range& e) {
59587       {
59588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59589       };
59590     } catch (std::exception& e) {
59591       {
59592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59593       };
59594     } catch (...) {
59595       {
59596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59597       };
59598     }
59599   }
59600   jresult = (int)result;
59601   return jresult;
59602 }
59603
59604
59605 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
59606   int jresult ;
59607   int result;
59608
59609   {
59610     try {
59611       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
59612     } catch (std::out_of_range& e) {
59613       {
59614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59615       };
59616     } catch (std::exception& e) {
59617       {
59618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59619       };
59620     } catch (...) {
59621       {
59622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59623       };
59624     }
59625   }
59626   jresult = (int)result;
59627   return jresult;
59628 }
59629
59630
59631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
59632   int jresult ;
59633   int result;
59634
59635   {
59636     try {
59637       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
59638     } catch (std::out_of_range& e) {
59639       {
59640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59641       };
59642     } catch (std::exception& e) {
59643       {
59644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59645       };
59646     } catch (...) {
59647       {
59648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59649       };
59650     }
59651   }
59652   jresult = (int)result;
59653   return jresult;
59654 }
59655
59656
59657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
59658   int jresult ;
59659   int result;
59660
59661   {
59662     try {
59663       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
59664     } catch (std::out_of_range& e) {
59665       {
59666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59667       };
59668     } catch (std::exception& e) {
59669       {
59670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59671       };
59672     } catch (...) {
59673       {
59674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59675       };
59676     }
59677   }
59678   jresult = (int)result;
59679   return jresult;
59680 }
59681
59682
59683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
59684   int jresult ;
59685   int result;
59686
59687   {
59688     try {
59689       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
59690     } catch (std::out_of_range& e) {
59691       {
59692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59693       };
59694     } catch (std::exception& e) {
59695       {
59696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59697       };
59698     } catch (...) {
59699       {
59700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59701       };
59702     }
59703   }
59704   jresult = (int)result;
59705   return jresult;
59706 }
59707
59708
59709 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
59710   int jresult ;
59711   int result;
59712
59713   {
59714     try {
59715       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
59716     } catch (std::out_of_range& e) {
59717       {
59718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59719       };
59720     } catch (std::exception& e) {
59721       {
59722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59723       };
59724     } catch (...) {
59725       {
59726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59727       };
59728     }
59729   }
59730   jresult = (int)result;
59731   return jresult;
59732 }
59733
59734
59735 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
59736   int jresult ;
59737   int result;
59738
59739   {
59740     try {
59741       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
59742     } catch (std::out_of_range& e) {
59743       {
59744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59745       };
59746     } catch (std::exception& e) {
59747       {
59748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59749       };
59750     } catch (...) {
59751       {
59752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59753       };
59754     }
59755   }
59756   jresult = (int)result;
59757   return jresult;
59758 }
59759
59760
59761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
59762   int jresult ;
59763   int result;
59764
59765   {
59766     try {
59767       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
59768     } catch (std::out_of_range& e) {
59769       {
59770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59771       };
59772     } catch (std::exception& e) {
59773       {
59774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59775       };
59776     } catch (...) {
59777       {
59778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59779       };
59780     }
59781   }
59782   jresult = (int)result;
59783   return jresult;
59784 }
59785
59786
59787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
59788   int jresult ;
59789   int result;
59790
59791   {
59792     try {
59793       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
59794     } catch (std::out_of_range& e) {
59795       {
59796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59797       };
59798     } catch (std::exception& e) {
59799       {
59800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59801       };
59802     } catch (...) {
59803       {
59804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59805       };
59806     }
59807   }
59808   jresult = (int)result;
59809   return jresult;
59810 }
59811
59812
59813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
59814   int jresult ;
59815   int result;
59816
59817   {
59818     try {
59819       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
59820     } catch (std::out_of_range& e) {
59821       {
59822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59823       };
59824     } catch (std::exception& e) {
59825       {
59826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59827       };
59828     } catch (...) {
59829       {
59830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59831       };
59832     }
59833   }
59834   jresult = (int)result;
59835   return jresult;
59836 }
59837
59838
59839 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
59840   int jresult ;
59841   int result;
59842
59843   {
59844     try {
59845       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
59846     } catch (std::out_of_range& e) {
59847       {
59848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59849       };
59850     } catch (std::exception& e) {
59851       {
59852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59853       };
59854     } catch (...) {
59855       {
59856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59857       };
59858     }
59859   }
59860   jresult = (int)result;
59861   return jresult;
59862 }
59863
59864
59865 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
59866   int jresult ;
59867   int result;
59868
59869   {
59870     try {
59871       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
59872     } catch (std::out_of_range& e) {
59873       {
59874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59875       };
59876     } catch (std::exception& e) {
59877       {
59878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59879       };
59880     } catch (...) {
59881       {
59882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59883       };
59884     }
59885   }
59886   jresult = (int)result;
59887   return jresult;
59888 }
59889
59890
59891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
59892   void * jresult ;
59893   Dali::Toolkit::Control result;
59894
59895   {
59896     try {
59897       result = Dali::Toolkit::Internal::Control::New();
59898     } catch (std::out_of_range& e) {
59899       {
59900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59901       };
59902     } catch (std::exception& e) {
59903       {
59904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59905       };
59906     } catch (...) {
59907       {
59908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59909       };
59910     }
59911   }
59912   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
59913   return jresult;
59914 }
59915
59916
59917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
59918   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59919   std::string *arg2 = 0 ;
59920
59921   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59922   if (!jarg2) {
59923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59924     return ;
59925   }
59926   std::string arg2_str(jarg2);
59927   arg2 = &arg2_str;
59928   {
59929     try {
59930       (arg1)->SetStyleName((std::string const &)*arg2);
59931     } catch (std::out_of_range& e) {
59932       {
59933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59934       };
59935     } catch (std::exception& e) {
59936       {
59937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59938       };
59939     } catch (...) {
59940       {
59941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59942       };
59943     }
59944   }
59945
59946   //argout typemap for const std::string&
59947
59948 }
59949
59950
59951 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
59952   char * jresult ;
59953   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59954   std::string *result = 0 ;
59955
59956   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59957   {
59958     try {
59959       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
59960     } catch (std::out_of_range& e) {
59961       {
59962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59963       };
59964     } catch (std::exception& e) {
59965       {
59966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59967       };
59968     } catch (...) {
59969       {
59970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59971       };
59972     }
59973   }
59974   jresult = SWIG_csharp_string_callback(result->c_str());
59975   return jresult;
59976 }
59977
59978
59979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
59980   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59981   Dali::Vector4 *arg2 = 0 ;
59982
59983   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59984   arg2 = (Dali::Vector4 *)jarg2;
59985   if (!arg2) {
59986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
59987     return ;
59988   }
59989   {
59990     try {
59991       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
59992     } catch (std::out_of_range& e) {
59993       {
59994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59995       };
59996     } catch (std::exception& e) {
59997       {
59998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59999       };
60000     } catch (...) {
60001       {
60002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60003       };
60004     }
60005   }
60006 }
60007
60008
60009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
60010   void * jresult ;
60011   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60012   Dali::Vector4 result;
60013
60014   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60015   {
60016     try {
60017       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
60018     } catch (std::out_of_range& e) {
60019       {
60020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60021       };
60022     } catch (std::exception& e) {
60023       {
60024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60025       };
60026     } catch (...) {
60027       {
60028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60029       };
60030     }
60031   }
60032   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
60033   return jresult;
60034 }
60035
60036
60037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
60038   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60039   Dali::Image arg2 ;
60040   Dali::Image *argp2 ;
60041
60042   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60043   argp2 = (Dali::Image *)jarg2;
60044   if (!argp2) {
60045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
60046     return ;
60047   }
60048   arg2 = *argp2;
60049   {
60050     try {
60051       (arg1)->SetBackgroundImage(arg2);
60052     } catch (std::out_of_range& e) {
60053       {
60054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60055       };
60056     } catch (std::exception& e) {
60057       {
60058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60059       };
60060     } catch (...) {
60061       {
60062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60063       };
60064     }
60065   }
60066 }
60067
60068
60069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
60070   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60071   Dali::Property::Map *arg2 = 0 ;
60072
60073   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60074   arg2 = (Dali::Property::Map *)jarg2;
60075   if (!arg2) {
60076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
60077     return ;
60078   }
60079   {
60080     try {
60081       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
60082     } catch (std::out_of_range& e) {
60083       {
60084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60085       };
60086     } catch (std::exception& e) {
60087       {
60088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60089       };
60090     } catch (...) {
60091       {
60092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60093       };
60094     }
60095   }
60096 }
60097
60098
60099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
60100   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60101
60102   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60103   {
60104     try {
60105       (arg1)->ClearBackground();
60106     } catch (std::out_of_range& e) {
60107       {
60108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60109       };
60110     } catch (std::exception& e) {
60111       {
60112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60113       };
60114     } catch (...) {
60115       {
60116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60117       };
60118     }
60119   }
60120 }
60121
60122
60123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
60124   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60125   Dali::Gesture::Type arg2 ;
60126
60127   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60128   arg2 = (Dali::Gesture::Type)jarg2;
60129   {
60130     try {
60131       (arg1)->EnableGestureDetection(arg2);
60132     } catch (std::out_of_range& e) {
60133       {
60134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60135       };
60136     } catch (std::exception& e) {
60137       {
60138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60139       };
60140     } catch (...) {
60141       {
60142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60143       };
60144     }
60145   }
60146 }
60147
60148
60149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
60150   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60151   Dali::Gesture::Type arg2 ;
60152
60153   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60154   arg2 = (Dali::Gesture::Type)jarg2;
60155   {
60156     try {
60157       (arg1)->DisableGestureDetection(arg2);
60158     } catch (std::out_of_range& e) {
60159       {
60160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60161       };
60162     } catch (std::exception& e) {
60163       {
60164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60165       };
60166     } catch (...) {
60167       {
60168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60169       };
60170     }
60171   }
60172 }
60173
60174
60175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
60176   void * jresult ;
60177   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60178   Dali::PinchGestureDetector result;
60179
60180   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60181   {
60182     try {
60183       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
60184     } catch (std::out_of_range& e) {
60185       {
60186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60187       };
60188     } catch (std::exception& e) {
60189       {
60190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60191       };
60192     } catch (...) {
60193       {
60194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60195       };
60196     }
60197   }
60198   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
60199   return jresult;
60200 }
60201
60202
60203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
60204   void * jresult ;
60205   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60206   Dali::PanGestureDetector result;
60207
60208   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60209   {
60210     try {
60211       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
60212     } catch (std::out_of_range& e) {
60213       {
60214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60215       };
60216     } catch (std::exception& e) {
60217       {
60218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60219       };
60220     } catch (...) {
60221       {
60222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60223       };
60224     }
60225   }
60226   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
60227   return jresult;
60228 }
60229
60230
60231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
60232   void * jresult ;
60233   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60234   Dali::TapGestureDetector result;
60235
60236   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60237   {
60238     try {
60239       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
60240     } catch (std::out_of_range& e) {
60241       {
60242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60243       };
60244     } catch (std::exception& e) {
60245       {
60246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60247       };
60248     } catch (...) {
60249       {
60250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60251       };
60252     }
60253   }
60254   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
60255   return jresult;
60256 }
60257
60258
60259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
60260   void * jresult ;
60261   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60262   Dali::LongPressGestureDetector result;
60263
60264   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60265   {
60266     try {
60267       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
60268     } catch (std::out_of_range& e) {
60269       {
60270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60271       };
60272     } catch (std::exception& e) {
60273       {
60274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60275       };
60276     } catch (...) {
60277       {
60278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60279       };
60280     }
60281   }
60282   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
60283   return jresult;
60284 }
60285
60286
60287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
60288   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60289   bool arg2 ;
60290
60291   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60292   arg2 = jarg2 ? true : false;
60293   {
60294     try {
60295       (arg1)->SetKeyboardNavigationSupport(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 unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
60314   unsigned int jresult ;
60315   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60316   bool result;
60317
60318   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60319   {
60320     try {
60321       result = (bool)(arg1)->IsKeyboardNavigationSupported();
60322     } catch (std::out_of_range& e) {
60323       {
60324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60325       };
60326     } catch (std::exception& e) {
60327       {
60328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60329       };
60330     } catch (...) {
60331       {
60332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60333       };
60334     }
60335   }
60336   jresult = result;
60337   return jresult;
60338 }
60339
60340
60341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
60342   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60343
60344   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60345   {
60346     try {
60347       (arg1)->SetKeyInputFocus();
60348     } catch (std::out_of_range& e) {
60349       {
60350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60351       };
60352     } catch (std::exception& e) {
60353       {
60354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60355       };
60356     } catch (...) {
60357       {
60358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60359       };
60360     }
60361   }
60362 }
60363
60364
60365 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
60366   unsigned int jresult ;
60367   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60368   bool result;
60369
60370   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60371   {
60372     try {
60373       result = (bool)(arg1)->HasKeyInputFocus();
60374     } catch (std::out_of_range& e) {
60375       {
60376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60377       };
60378     } catch (std::exception& e) {
60379       {
60380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60381       };
60382     } catch (...) {
60383       {
60384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60385       };
60386     }
60387   }
60388   jresult = result;
60389   return jresult;
60390 }
60391
60392
60393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
60394   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60395
60396   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60397   {
60398     try {
60399       (arg1)->ClearKeyInputFocus();
60400     } catch (std::out_of_range& e) {
60401       {
60402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60403       };
60404     } catch (std::exception& e) {
60405       {
60406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60407       };
60408     } catch (...) {
60409       {
60410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60411       };
60412     }
60413   }
60414 }
60415
60416
60417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
60418   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60419   bool arg2 ;
60420
60421   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60422   arg2 = jarg2 ? true : false;
60423   {
60424     try {
60425       (arg1)->SetAsKeyboardFocusGroup(arg2);
60426     } catch (std::out_of_range& e) {
60427       {
60428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60429       };
60430     } catch (std::exception& e) {
60431       {
60432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60433       };
60434     } catch (...) {
60435       {
60436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60437       };
60438     }
60439   }
60440 }
60441
60442
60443 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
60444   unsigned int jresult ;
60445   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60446   bool result;
60447
60448   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60449   {
60450     try {
60451       result = (bool)(arg1)->IsKeyboardFocusGroup();
60452     } catch (std::out_of_range& e) {
60453       {
60454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60455       };
60456     } catch (std::exception& e) {
60457       {
60458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60459       };
60460     } catch (...) {
60461       {
60462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60463       };
60464     }
60465   }
60466   jresult = result;
60467   return jresult;
60468 }
60469
60470
60471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_AccessibilityActivate(void * jarg1) {
60472   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60473
60474   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60475   {
60476     try {
60477       (arg1)->AccessibilityActivate();
60478     } catch (std::out_of_range& e) {
60479       {
60480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60481       };
60482     } catch (std::exception& e) {
60483       {
60484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60485       };
60486     } catch (...) {
60487       {
60488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60489       };
60490     }
60491   }
60492 }
60493
60494
60495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_KeyboardEnter(void * jarg1) {
60496   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60497
60498   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60499   {
60500     try {
60501       (arg1)->KeyboardEnter();
60502     } catch (std::out_of_range& e) {
60503       {
60504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60505       };
60506     } catch (std::exception& e) {
60507       {
60508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60509       };
60510     } catch (...) {
60511       {
60512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60513       };
60514     }
60515   }
60516 }
60517
60518
60519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
60520   void * jresult ;
60521   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60522   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
60523
60524   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60525   {
60526     try {
60527       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
60528     } catch (std::out_of_range& e) {
60529       {
60530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60531       };
60532     } catch (std::exception& e) {
60533       {
60534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60535       };
60536     } catch (...) {
60537       {
60538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60539       };
60540     }
60541   }
60542   jresult = (void *)result;
60543   return jresult;
60544 }
60545
60546
60547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
60548   void * jresult ;
60549   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60550   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
60551
60552   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60553   {
60554     try {
60555       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
60556     } catch (std::out_of_range& e) {
60557       {
60558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60559       };
60560     } catch (std::exception& e) {
60561       {
60562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60563       };
60564     } catch (...) {
60565       {
60566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60567       };
60568     }
60569   }
60570   jresult = (void *)result;
60571   return jresult;
60572 }
60573
60574
60575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
60576   void * jresult ;
60577   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60578   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
60579
60580   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60581   {
60582     try {
60583       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
60584     } catch (std::out_of_range& e) {
60585       {
60586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60587       };
60588     } catch (std::exception& e) {
60589       {
60590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60591       };
60592     } catch (...) {
60593       {
60594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60595       };
60596     }
60597   }
60598   jresult = (void *)result;
60599   return jresult;
60600 }
60601
60602
60603 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_EmitKeyEventSignal(void * jarg1, void * jarg2) {
60604   unsigned int jresult ;
60605   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60606   Dali::KeyEvent *arg2 = 0 ;
60607   bool result;
60608
60609   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60610   arg2 = (Dali::KeyEvent *)jarg2;
60611   if (!arg2) {
60612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60613     return 0;
60614   }
60615   {
60616     try {
60617       result = (bool)(arg1)->EmitKeyEventSignal((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 void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
60638   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60639   int arg2 ;
60640   SwigDirector_ViewImpl *darg = 0;
60641
60642   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60643   arg2 = (int)jarg2;
60644   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60645   {
60646     try {
60647       (darg)->OnStageConnection(arg2);
60648     } catch (std::out_of_range& e) {
60649       {
60650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60651       };
60652     } catch (std::exception& e) {
60653       {
60654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60655       };
60656     } catch (...) {
60657       {
60658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60659       };
60660     }
60661   }
60662 }
60663
60664
60665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
60666   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60667   int arg2 ;
60668   SwigDirector_ViewImpl *darg = 0;
60669
60670   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60671   arg2 = (int)jarg2;
60672   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60673   {
60674     try {
60675       (darg)->OnStageConnectionSwigPublic(arg2);
60676     } catch (std::out_of_range& e) {
60677       {
60678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60679       };
60680     } catch (std::exception& e) {
60681       {
60682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60683       };
60684     } catch (...) {
60685       {
60686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60687       };
60688     }
60689   }
60690 }
60691
60692
60693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
60694   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60695   SwigDirector_ViewImpl *darg = 0;
60696
60697   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60698   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60699   {
60700     try {
60701       (darg)->OnStageDisconnection();
60702     } catch (std::out_of_range& e) {
60703       {
60704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60705       };
60706     } catch (std::exception& e) {
60707       {
60708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60709       };
60710     } catch (...) {
60711       {
60712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60713       };
60714     }
60715   }
60716 }
60717
60718
60719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
60720   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60721   SwigDirector_ViewImpl *darg = 0;
60722
60723   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60724   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60725   {
60726     try {
60727       (darg)->OnStageDisconnectionSwigPublic();
60728     } catch (std::out_of_range& e) {
60729       {
60730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60731       };
60732     } catch (std::exception& e) {
60733       {
60734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60735       };
60736     } catch (...) {
60737       {
60738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60739       };
60740     }
60741   }
60742 }
60743
60744
60745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
60746   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60747   Dali::Actor *arg2 = 0 ;
60748   SwigDirector_ViewImpl *darg = 0;
60749
60750   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60751   arg2 = (Dali::Actor *)jarg2;
60752   if (!arg2) {
60753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60754     return ;
60755   }
60756   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60757   {
60758     try {
60759       (darg)->OnChildAdd(*arg2);
60760     } catch (std::out_of_range& e) {
60761       {
60762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60763       };
60764     } catch (std::exception& e) {
60765       {
60766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60767       };
60768     } catch (...) {
60769       {
60770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60771       };
60772     }
60773   }
60774 }
60775
60776
60777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60778   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60779   Dali::Actor *arg2 = 0 ;
60780   SwigDirector_ViewImpl *darg = 0;
60781
60782   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60783   arg2 = (Dali::Actor *)jarg2;
60784   if (!arg2) {
60785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60786     return ;
60787   }
60788   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60789   {
60790     try {
60791       (darg)->OnChildAddSwigPublic(*arg2);
60792     } catch (std::out_of_range& e) {
60793       {
60794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60795       };
60796     } catch (std::exception& e) {
60797       {
60798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60799       };
60800     } catch (...) {
60801       {
60802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60803       };
60804     }
60805   }
60806 }
60807
60808
60809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
60810   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60811   Dali::Actor *arg2 = 0 ;
60812   SwigDirector_ViewImpl *darg = 0;
60813
60814   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60815   arg2 = (Dali::Actor *)jarg2;
60816   if (!arg2) {
60817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60818     return ;
60819   }
60820   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60821   {
60822     try {
60823       (darg)->OnChildRemove(*arg2);
60824     } catch (std::out_of_range& e) {
60825       {
60826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60827       };
60828     } catch (std::exception& e) {
60829       {
60830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60831       };
60832     } catch (...) {
60833       {
60834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60835       };
60836     }
60837   }
60838 }
60839
60840
60841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60842   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60843   Dali::Actor *arg2 = 0 ;
60844   SwigDirector_ViewImpl *darg = 0;
60845
60846   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60847   arg2 = (Dali::Actor *)jarg2;
60848   if (!arg2) {
60849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60850     return ;
60851   }
60852   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60853   {
60854     try {
60855       (darg)->OnChildRemoveSwigPublic(*arg2);
60856     } catch (std::out_of_range& e) {
60857       {
60858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60859       };
60860     } catch (std::exception& e) {
60861       {
60862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60863       };
60864     } catch (...) {
60865       {
60866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60867       };
60868     }
60869   }
60870 }
60871
60872
60873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
60874   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60875   Dali::Property::Index arg2 ;
60876   Dali::Property::Value arg3 ;
60877   Dali::Property::Value *argp3 ;
60878   SwigDirector_ViewImpl *darg = 0;
60879
60880   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60881   arg2 = (Dali::Property::Index)jarg2;
60882   argp3 = (Dali::Property::Value *)jarg3;
60883   if (!argp3) {
60884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60885     return ;
60886   }
60887   arg3 = *argp3;
60888   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60889   {
60890     try {
60891       (darg)->OnPropertySet(arg2,arg3);
60892     } catch (std::out_of_range& e) {
60893       {
60894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60895       };
60896     } catch (std::exception& e) {
60897       {
60898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60899       };
60900     } catch (...) {
60901       {
60902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60903       };
60904     }
60905   }
60906 }
60907
60908
60909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
60910   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60911   Dali::Property::Index arg2 ;
60912   Dali::Property::Value arg3 ;
60913   Dali::Property::Value *argp3 ;
60914   SwigDirector_ViewImpl *darg = 0;
60915
60916   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60917   arg2 = (Dali::Property::Index)jarg2;
60918   argp3 = (Dali::Property::Value *)jarg3;
60919   if (!argp3) {
60920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60921     return ;
60922   }
60923   arg3 = *argp3;
60924   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60925   {
60926     try {
60927       (darg)->OnPropertySetSwigPublic(arg2,arg3);
60928     } catch (std::out_of_range& e) {
60929       {
60930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60931       };
60932     } catch (std::exception& e) {
60933       {
60934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60935       };
60936     } catch (...) {
60937       {
60938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60939       };
60940     }
60941   }
60942 }
60943
60944
60945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
60946   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60947   Dali::Vector3 *arg2 = 0 ;
60948   SwigDirector_ViewImpl *darg = 0;
60949
60950   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60951   arg2 = (Dali::Vector3 *)jarg2;
60952   if (!arg2) {
60953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60954     return ;
60955   }
60956   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60957   {
60958     try {
60959       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
60960     } catch (std::out_of_range& e) {
60961       {
60962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60963       };
60964     } catch (std::exception& e) {
60965       {
60966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60967       };
60968     } catch (...) {
60969       {
60970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60971       };
60972     }
60973   }
60974 }
60975
60976
60977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60978   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60979   Dali::Vector3 *arg2 = 0 ;
60980   SwigDirector_ViewImpl *darg = 0;
60981
60982   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60983   arg2 = (Dali::Vector3 *)jarg2;
60984   if (!arg2) {
60985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60986     return ;
60987   }
60988   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60989   {
60990     try {
60991       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
60992     } catch (std::out_of_range& e) {
60993       {
60994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60995       };
60996     } catch (std::exception& e) {
60997       {
60998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60999       };
61000     } catch (...) {
61001       {
61002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61003       };
61004     }
61005   }
61006 }
61007
61008
61009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
61010   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61011   Dali::Animation *arg2 = 0 ;
61012   Dali::Vector3 *arg3 = 0 ;
61013   SwigDirector_ViewImpl *darg = 0;
61014
61015   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61016   arg2 = (Dali::Animation *)jarg2;
61017   if (!arg2) {
61018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
61019     return ;
61020   }
61021   arg3 = (Dali::Vector3 *)jarg3;
61022   if (!arg3) {
61023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
61024     return ;
61025   }
61026   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61027   {
61028     try {
61029       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
61030     } catch (std::out_of_range& e) {
61031       {
61032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61033       };
61034     } catch (std::exception& e) {
61035       {
61036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61037       };
61038     } catch (...) {
61039       {
61040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61041       };
61042     }
61043   }
61044 }
61045
61046
61047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
61048   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61049   Dali::Animation *arg2 = 0 ;
61050   Dali::Vector3 *arg3 = 0 ;
61051   SwigDirector_ViewImpl *darg = 0;
61052
61053   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61054   arg2 = (Dali::Animation *)jarg2;
61055   if (!arg2) {
61056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
61057     return ;
61058   }
61059   arg3 = (Dali::Vector3 *)jarg3;
61060   if (!arg3) {
61061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
61062     return ;
61063   }
61064   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61065   {
61066     try {
61067       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
61068     } catch (std::out_of_range& e) {
61069       {
61070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61071       };
61072     } catch (std::exception& e) {
61073       {
61074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61075       };
61076     } catch (...) {
61077       {
61078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61079       };
61080     }
61081   }
61082 }
61083
61084
61085 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
61086   unsigned int jresult ;
61087   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61088   Dali::TouchEvent *arg2 = 0 ;
61089   SwigDirector_ViewImpl *darg = 0;
61090   bool result;
61091
61092   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61093   arg2 = (Dali::TouchEvent *)jarg2;
61094   if (!arg2) {
61095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61096     return 0;
61097   }
61098   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61099   {
61100     try {
61101       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
61102     } catch (std::out_of_range& e) {
61103       {
61104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61105       };
61106     } catch (std::exception& e) {
61107       {
61108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61109       };
61110     } catch (...) {
61111       {
61112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61113       };
61114     }
61115   }
61116   jresult = result;
61117   return jresult;
61118 }
61119
61120
61121 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61122   unsigned int jresult ;
61123   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61124   Dali::TouchEvent *arg2 = 0 ;
61125   SwigDirector_ViewImpl *darg = 0;
61126   bool result;
61127
61128   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61129   arg2 = (Dali::TouchEvent *)jarg2;
61130   if (!arg2) {
61131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61132     return 0;
61133   }
61134   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61135   {
61136     try {
61137       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
61138     } catch (std::out_of_range& e) {
61139       {
61140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61141       };
61142     } catch (std::exception& e) {
61143       {
61144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61145       };
61146     } catch (...) {
61147       {
61148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61149       };
61150     }
61151   }
61152   jresult = result;
61153   return jresult;
61154 }
61155
61156
61157 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
61158   unsigned int jresult ;
61159   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61160   Dali::HoverEvent *arg2 = 0 ;
61161   SwigDirector_ViewImpl *darg = 0;
61162   bool result;
61163
61164   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61165   arg2 = (Dali::HoverEvent *)jarg2;
61166   if (!arg2) {
61167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
61168     return 0;
61169   }
61170   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61171   {
61172     try {
61173       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
61174     } catch (std::out_of_range& e) {
61175       {
61176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61177       };
61178     } catch (std::exception& e) {
61179       {
61180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61181       };
61182     } catch (...) {
61183       {
61184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61185       };
61186     }
61187   }
61188   jresult = result;
61189   return jresult;
61190 }
61191
61192
61193 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61194   unsigned int jresult ;
61195   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61196   Dali::HoverEvent *arg2 = 0 ;
61197   SwigDirector_ViewImpl *darg = 0;
61198   bool result;
61199
61200   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61201   arg2 = (Dali::HoverEvent *)jarg2;
61202   if (!arg2) {
61203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
61204     return 0;
61205   }
61206   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61207   {
61208     try {
61209       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
61210     } catch (std::out_of_range& e) {
61211       {
61212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61213       };
61214     } catch (std::exception& e) {
61215       {
61216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61217       };
61218     } catch (...) {
61219       {
61220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61221       };
61222     }
61223   }
61224   jresult = result;
61225   return jresult;
61226 }
61227
61228
61229 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
61230   unsigned int jresult ;
61231   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61232   Dali::KeyEvent *arg2 = 0 ;
61233   SwigDirector_ViewImpl *darg = 0;
61234   bool result;
61235
61236   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61237   arg2 = (Dali::KeyEvent *)jarg2;
61238   if (!arg2) {
61239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
61240     return 0;
61241   }
61242   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61243   {
61244     try {
61245       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
61246     } catch (std::out_of_range& e) {
61247       {
61248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61249       };
61250     } catch (std::exception& e) {
61251       {
61252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61253       };
61254     } catch (...) {
61255       {
61256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61257       };
61258     }
61259   }
61260   jresult = result;
61261   return jresult;
61262 }
61263
61264
61265 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61266   unsigned int jresult ;
61267   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61268   Dali::KeyEvent *arg2 = 0 ;
61269   SwigDirector_ViewImpl *darg = 0;
61270   bool result;
61271
61272   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61273   arg2 = (Dali::KeyEvent *)jarg2;
61274   if (!arg2) {
61275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
61276     return 0;
61277   }
61278   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61279   {
61280     try {
61281       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
61282     } catch (std::out_of_range& e) {
61283       {
61284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61285       };
61286     } catch (std::exception& e) {
61287       {
61288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61289       };
61290     } catch (...) {
61291       {
61292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61293       };
61294     }
61295   }
61296   jresult = result;
61297   return jresult;
61298 }
61299
61300
61301 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
61302   unsigned int jresult ;
61303   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61304   Dali::WheelEvent *arg2 = 0 ;
61305   SwigDirector_ViewImpl *darg = 0;
61306   bool result;
61307
61308   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61309   arg2 = (Dali::WheelEvent *)jarg2;
61310   if (!arg2) {
61311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
61312     return 0;
61313   }
61314   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61315   {
61316     try {
61317       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
61318     } catch (std::out_of_range& e) {
61319       {
61320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61321       };
61322     } catch (std::exception& e) {
61323       {
61324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61325       };
61326     } catch (...) {
61327       {
61328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61329       };
61330     }
61331   }
61332   jresult = result;
61333   return jresult;
61334 }
61335
61336
61337 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61338   unsigned int jresult ;
61339   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61340   Dali::WheelEvent *arg2 = 0 ;
61341   SwigDirector_ViewImpl *darg = 0;
61342   bool result;
61343
61344   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61345   arg2 = (Dali::WheelEvent *)jarg2;
61346   if (!arg2) {
61347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
61348     return 0;
61349   }
61350   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61351   {
61352     try {
61353       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
61354     } catch (std::out_of_range& e) {
61355       {
61356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61357       };
61358     } catch (std::exception& e) {
61359       {
61360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61361       };
61362     } catch (...) {
61363       {
61364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61365       };
61366     }
61367   }
61368   jresult = result;
61369   return jresult;
61370 }
61371
61372
61373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
61374   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61375   Dali::Vector2 *arg2 = 0 ;
61376   Dali::RelayoutContainer *arg3 = 0 ;
61377   SwigDirector_ViewImpl *darg = 0;
61378
61379   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61380   arg2 = (Dali::Vector2 *)jarg2;
61381   if (!arg2) {
61382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
61383     return ;
61384   }
61385   arg3 = (Dali::RelayoutContainer *)jarg3;
61386   if (!arg3) {
61387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
61388     return ;
61389   }
61390   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61391   {
61392     try {
61393       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
61394     } catch (std::out_of_range& e) {
61395       {
61396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61397       };
61398     } catch (std::exception& e) {
61399       {
61400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61401       };
61402     } catch (...) {
61403       {
61404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61405       };
61406     }
61407   }
61408 }
61409
61410
61411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
61412   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61413   Dali::Vector2 *arg2 = 0 ;
61414   Dali::RelayoutContainer *arg3 = 0 ;
61415   SwigDirector_ViewImpl *darg = 0;
61416
61417   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61418   arg2 = (Dali::Vector2 *)jarg2;
61419   if (!arg2) {
61420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
61421     return ;
61422   }
61423   arg3 = (Dali::RelayoutContainer *)jarg3;
61424   if (!arg3) {
61425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
61426     return ;
61427   }
61428   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61429   {
61430     try {
61431       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
61432     } catch (std::out_of_range& e) {
61433       {
61434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61435       };
61436     } catch (std::exception& e) {
61437       {
61438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61439       };
61440     } catch (...) {
61441       {
61442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61443       };
61444     }
61445   }
61446 }
61447
61448
61449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
61450   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61451   Dali::ResizePolicy::Type arg2 ;
61452   Dali::Dimension::Type arg3 ;
61453   SwigDirector_ViewImpl *darg = 0;
61454
61455   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61456   arg2 = (Dali::ResizePolicy::Type)jarg2;
61457   arg3 = (Dali::Dimension::Type)jarg3;
61458   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61459   {
61460     try {
61461       (darg)->OnSetResizePolicy(arg2,arg3);
61462     } catch (std::out_of_range& e) {
61463       {
61464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61465       };
61466     } catch (std::exception& e) {
61467       {
61468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61469       };
61470     } catch (...) {
61471       {
61472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61473       };
61474     }
61475   }
61476 }
61477
61478
61479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
61480   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61481   Dali::ResizePolicy::Type arg2 ;
61482   Dali::Dimension::Type arg3 ;
61483   SwigDirector_ViewImpl *darg = 0;
61484
61485   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61486   arg2 = (Dali::ResizePolicy::Type)jarg2;
61487   arg3 = (Dali::Dimension::Type)jarg3;
61488   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61489   {
61490     try {
61491       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
61492     } catch (std::out_of_range& e) {
61493       {
61494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61495       };
61496     } catch (std::exception& e) {
61497       {
61498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61499       };
61500     } catch (...) {
61501       {
61502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61503       };
61504     }
61505   }
61506 }
61507
61508
61509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
61510   void * jresult ;
61511   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61512   SwigDirector_ViewImpl *darg = 0;
61513   Dali::Vector3 result;
61514
61515   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61516   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61517   {
61518     try {
61519       result = (darg)->GetNaturalSize();
61520     } catch (std::out_of_range& e) {
61521       {
61522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61523       };
61524     } catch (std::exception& e) {
61525       {
61526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61527       };
61528     } catch (...) {
61529       {
61530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61531       };
61532     }
61533   }
61534   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
61535   return jresult;
61536 }
61537
61538
61539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
61540   void * jresult ;
61541   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61542   SwigDirector_ViewImpl *darg = 0;
61543   Dali::Vector3 result;
61544
61545   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61546   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61547   {
61548     try {
61549       result = (darg)->GetNaturalSizeSwigPublic();
61550     } catch (std::out_of_range& e) {
61551       {
61552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61553       };
61554     } catch (std::exception& e) {
61555       {
61556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61557       };
61558     } catch (...) {
61559       {
61560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61561       };
61562     }
61563   }
61564   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
61565   return jresult;
61566 }
61567
61568
61569 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
61570   float jresult ;
61571   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61572   Dali::Actor *arg2 = 0 ;
61573   Dali::Dimension::Type arg3 ;
61574   SwigDirector_ViewImpl *darg = 0;
61575   float result;
61576
61577   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61578   arg2 = (Dali::Actor *)jarg2;
61579   if (!arg2) {
61580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
61581     return 0;
61582   }
61583   arg3 = (Dali::Dimension::Type)jarg3;
61584   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61585   {
61586     try {
61587       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
61588     } catch (std::out_of_range& e) {
61589       {
61590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61591       };
61592     } catch (std::exception& e) {
61593       {
61594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61595       };
61596     } catch (...) {
61597       {
61598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61599       };
61600     }
61601   }
61602   jresult = result;
61603   return jresult;
61604 }
61605
61606
61607 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61608   float jresult ;
61609   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61610   Dali::Actor *arg2 = 0 ;
61611   Dali::Dimension::Type arg3 ;
61612   SwigDirector_ViewImpl *darg = 0;
61613   float result;
61614
61615   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61616   arg2 = (Dali::Actor *)jarg2;
61617   if (!arg2) {
61618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
61619     return 0;
61620   }
61621   arg3 = (Dali::Dimension::Type)jarg3;
61622   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61623   {
61624     try {
61625       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
61626     } catch (std::out_of_range& e) {
61627       {
61628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61629       };
61630     } catch (std::exception& e) {
61631       {
61632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61633       };
61634     } catch (...) {
61635       {
61636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61637       };
61638     }
61639   }
61640   jresult = result;
61641   return jresult;
61642 }
61643
61644
61645 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
61646   float jresult ;
61647   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61648   float arg2 ;
61649   SwigDirector_ViewImpl *darg = 0;
61650   float result;
61651
61652   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61653   arg2 = (float)jarg2;
61654   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61655   {
61656     try {
61657       result = (float)(darg)->GetHeightForWidth(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 float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
61678   float jresult ;
61679   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61680   float arg2 ;
61681   SwigDirector_ViewImpl *darg = 0;
61682   float result;
61683
61684   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61685   arg2 = (float)jarg2;
61686   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61687   {
61688     try {
61689       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
61690     } catch (std::out_of_range& e) {
61691       {
61692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61693       };
61694     } catch (std::exception& e) {
61695       {
61696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61697       };
61698     } catch (...) {
61699       {
61700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61701       };
61702     }
61703   }
61704   jresult = result;
61705   return jresult;
61706 }
61707
61708
61709 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
61710   float jresult ;
61711   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61712   float arg2 ;
61713   SwigDirector_ViewImpl *darg = 0;
61714   float result;
61715
61716   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61717   arg2 = (float)jarg2;
61718   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61719   {
61720     try {
61721       result = (float)(darg)->GetWidthForHeight(arg2);
61722     } catch (std::out_of_range& e) {
61723       {
61724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61725       };
61726     } catch (std::exception& e) {
61727       {
61728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61729       };
61730     } catch (...) {
61731       {
61732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61733       };
61734     }
61735   }
61736   jresult = result;
61737   return jresult;
61738 }
61739
61740
61741 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
61742   float jresult ;
61743   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61744   float arg2 ;
61745   SwigDirector_ViewImpl *darg = 0;
61746   float result;
61747
61748   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61749   arg2 = (float)jarg2;
61750   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61751   {
61752     try {
61753       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
61754     } catch (std::out_of_range& e) {
61755       {
61756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61757       };
61758     } catch (std::exception& e) {
61759       {
61760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61761       };
61762     } catch (...) {
61763       {
61764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61765       };
61766     }
61767   }
61768   jresult = result;
61769   return jresult;
61770 }
61771
61772
61773 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
61774   unsigned int jresult ;
61775   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61776   Dali::Dimension::Type arg2 ;
61777   SwigDirector_ViewImpl *darg = 0;
61778   bool result;
61779
61780   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61781   arg2 = (Dali::Dimension::Type)jarg2;
61782   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61783   {
61784     try {
61785       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
61786     } catch (std::out_of_range& e) {
61787       {
61788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61789       };
61790     } catch (std::exception& e) {
61791       {
61792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61793       };
61794     } catch (...) {
61795       {
61796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61797       };
61798     }
61799   }
61800   jresult = result;
61801   return jresult;
61802 }
61803
61804
61805 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
61806   unsigned int jresult ;
61807   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61808   Dali::Dimension::Type arg2 ;
61809   SwigDirector_ViewImpl *darg = 0;
61810   bool result;
61811
61812   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61813   arg2 = (Dali::Dimension::Type)jarg2;
61814   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61815   {
61816     try {
61817       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
61818     } catch (std::out_of_range& e) {
61819       {
61820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61821       };
61822     } catch (std::exception& e) {
61823       {
61824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61825       };
61826     } catch (...) {
61827       {
61828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61829       };
61830     }
61831   }
61832   jresult = result;
61833   return jresult;
61834 }
61835
61836
61837 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
61838   unsigned int jresult ;
61839   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61840   SwigDirector_ViewImpl *darg = 0;
61841   bool result;
61842
61843   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61844   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61845   {
61846     try {
61847       result = (bool)(darg)->RelayoutDependentOnChildren();
61848     } catch (std::out_of_range& e) {
61849       {
61850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61851       };
61852     } catch (std::exception& e) {
61853       {
61854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61855       };
61856     } catch (...) {
61857       {
61858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61859       };
61860     }
61861   }
61862   jresult = result;
61863   return jresult;
61864 }
61865
61866
61867 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
61868   unsigned int jresult ;
61869   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61870   SwigDirector_ViewImpl *darg = 0;
61871   bool result;
61872
61873   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61874   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61875   {
61876     try {
61877       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
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_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
61898   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61899   Dali::Dimension::Type arg2 ;
61900   SwigDirector_ViewImpl *darg = 0;
61901
61902   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61903   arg2 = (Dali::Dimension::Type)jarg2;
61904   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61905   {
61906     try {
61907       (darg)->OnCalculateRelayoutSize(arg2);
61908     } catch (std::out_of_range& e) {
61909       {
61910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61911       };
61912     } catch (std::exception& e) {
61913       {
61914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61915       };
61916     } catch (...) {
61917       {
61918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61919       };
61920     }
61921   }
61922 }
61923
61924
61925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
61926   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61927   Dali::Dimension::Type arg2 ;
61928   SwigDirector_ViewImpl *darg = 0;
61929
61930   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61931   arg2 = (Dali::Dimension::Type)jarg2;
61932   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61933   {
61934     try {
61935       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
61936     } catch (std::out_of_range& e) {
61937       {
61938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61939       };
61940     } catch (std::exception& e) {
61941       {
61942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61943       };
61944     } catch (...) {
61945       {
61946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61947       };
61948     }
61949   }
61950 }
61951
61952
61953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
61954   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61955   float arg2 ;
61956   Dali::Dimension::Type arg3 ;
61957   SwigDirector_ViewImpl *darg = 0;
61958
61959   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61960   arg2 = (float)jarg2;
61961   arg3 = (Dali::Dimension::Type)jarg3;
61962   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61963   {
61964     try {
61965       (darg)->OnLayoutNegotiated(arg2,arg3);
61966     } catch (std::out_of_range& e) {
61967       {
61968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61969       };
61970     } catch (std::exception& e) {
61971       {
61972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61973       };
61974     } catch (...) {
61975       {
61976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61977       };
61978     }
61979   }
61980 }
61981
61982
61983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
61984   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61985   float arg2 ;
61986   Dali::Dimension::Type arg3 ;
61987   SwigDirector_ViewImpl *darg = 0;
61988
61989   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61990   arg2 = (float)jarg2;
61991   arg3 = (Dali::Dimension::Type)jarg3;
61992   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61993   {
61994     try {
61995       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
61996     } catch (std::out_of_range& e) {
61997       {
61998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61999       };
62000     } catch (std::exception& e) {
62001       {
62002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62003       };
62004     } catch (...) {
62005       {
62006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62007       };
62008     }
62009   }
62010 }
62011
62012
62013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
62014   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62015
62016   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62017   {
62018     try {
62019       (arg1)->OnInitialize();
62020     } catch (std::out_of_range& e) {
62021       {
62022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62023       };
62024     } catch (std::exception& e) {
62025       {
62026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62027       };
62028     } catch (...) {
62029       {
62030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62031       };
62032     }
62033   }
62034 }
62035
62036
62037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
62038   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62039
62040   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62041   {
62042     try {
62043       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
62044     } catch (std::out_of_range& e) {
62045       {
62046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62047       };
62048     } catch (std::exception& e) {
62049       {
62050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62051       };
62052     } catch (...) {
62053       {
62054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62055       };
62056     }
62057   }
62058 }
62059
62060
62061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
62062   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62063   Dali::Actor *arg2 = 0 ;
62064
62065   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62066   arg2 = (Dali::Actor *)jarg2;
62067   if (!arg2) {
62068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62069     return ;
62070   }
62071   {
62072     try {
62073       (arg1)->OnControlChildAdd(*arg2);
62074     } catch (std::out_of_range& e) {
62075       {
62076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62077       };
62078     } catch (std::exception& e) {
62079       {
62080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62081       };
62082     } catch (...) {
62083       {
62084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62085       };
62086     }
62087   }
62088 }
62089
62090
62091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62092   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62093   Dali::Actor *arg2 = 0 ;
62094
62095   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62096   arg2 = (Dali::Actor *)jarg2;
62097   if (!arg2) {
62098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62099     return ;
62100   }
62101   {
62102     try {
62103       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
62104     } catch (std::out_of_range& e) {
62105       {
62106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62107       };
62108     } catch (std::exception& e) {
62109       {
62110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62111       };
62112     } catch (...) {
62113       {
62114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62115       };
62116     }
62117   }
62118 }
62119
62120
62121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
62122   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62123   Dali::Actor *arg2 = 0 ;
62124
62125   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62126   arg2 = (Dali::Actor *)jarg2;
62127   if (!arg2) {
62128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62129     return ;
62130   }
62131   {
62132     try {
62133       (arg1)->OnControlChildRemove(*arg2);
62134     } catch (std::out_of_range& e) {
62135       {
62136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62137       };
62138     } catch (std::exception& e) {
62139       {
62140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62141       };
62142     } catch (...) {
62143       {
62144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62145       };
62146     }
62147   }
62148 }
62149
62150
62151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62152   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62153   Dali::Actor *arg2 = 0 ;
62154
62155   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62156   arg2 = (Dali::Actor *)jarg2;
62157   if (!arg2) {
62158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62159     return ;
62160   }
62161   {
62162     try {
62163       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
62164     } catch (std::out_of_range& e) {
62165       {
62166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62167       };
62168     } catch (std::exception& e) {
62169       {
62170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62171       };
62172     } catch (...) {
62173       {
62174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62175       };
62176     }
62177   }
62178 }
62179
62180
62181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
62182   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62183   Dali::Toolkit::StyleManager arg2 ;
62184   Dali::StyleChange::Type arg3 ;
62185   Dali::Toolkit::StyleManager *argp2 ;
62186
62187   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62188   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
62189   if (!argp2) {
62190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
62191     return ;
62192   }
62193   arg2 = *argp2;
62194   arg3 = (Dali::StyleChange::Type)jarg3;
62195   {
62196     try {
62197       (arg1)->OnStyleChange(arg2,arg3);
62198     } catch (std::out_of_range& e) {
62199       {
62200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62201       };
62202     } catch (std::exception& e) {
62203       {
62204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62205       };
62206     } catch (...) {
62207       {
62208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62209       };
62210     }
62211   }
62212 }
62213
62214
62215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
62216   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62217   Dali::Toolkit::StyleManager arg2 ;
62218   Dali::StyleChange::Type arg3 ;
62219   Dali::Toolkit::StyleManager *argp2 ;
62220
62221   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62222   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
62223   if (!argp2) {
62224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
62225     return ;
62226   }
62227   arg2 = *argp2;
62228   arg3 = (Dali::StyleChange::Type)jarg3;
62229   {
62230     try {
62231       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
62232     } catch (std::out_of_range& e) {
62233       {
62234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62235       };
62236     } catch (std::exception& e) {
62237       {
62238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62239       };
62240     } catch (...) {
62241       {
62242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62243       };
62244     }
62245   }
62246 }
62247
62248
62249 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
62250   unsigned int jresult ;
62251   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62252   bool result;
62253
62254   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62255   {
62256     try {
62257       result = (bool)(arg1)->OnAccessibilityActivated();
62258     } catch (std::out_of_range& e) {
62259       {
62260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62261       };
62262     } catch (std::exception& e) {
62263       {
62264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62265       };
62266     } catch (...) {
62267       {
62268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62269       };
62270     }
62271   }
62272   jresult = result;
62273   return jresult;
62274 }
62275
62276
62277 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
62278   unsigned int jresult ;
62279   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62280   bool result;
62281
62282   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62283   {
62284     try {
62285       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
62286     } catch (std::out_of_range& e) {
62287       {
62288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62289       };
62290     } catch (std::exception& e) {
62291       {
62292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62293       };
62294     } catch (...) {
62295       {
62296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62297       };
62298     }
62299   }
62300   jresult = result;
62301   return jresult;
62302 }
62303
62304
62305 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
62306   unsigned int jresult ;
62307   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62308   Dali::PanGesture arg2 ;
62309   Dali::PanGesture *argp2 ;
62310   bool result;
62311
62312   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62313   argp2 = (Dali::PanGesture *)jarg2;
62314   if (!argp2) {
62315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
62316     return 0;
62317   }
62318   arg2 = *argp2;
62319   {
62320     try {
62321       result = (bool)(arg1)->OnAccessibilityPan(arg2);
62322     } catch (std::out_of_range& e) {
62323       {
62324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62325       };
62326     } catch (std::exception& e) {
62327       {
62328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62329       };
62330     } catch (...) {
62331       {
62332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62333       };
62334     }
62335   }
62336   jresult = result;
62337   return jresult;
62338 }
62339
62340
62341 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62342   unsigned int jresult ;
62343   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62344   Dali::PanGesture arg2 ;
62345   Dali::PanGesture *argp2 ;
62346   bool result;
62347
62348   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62349   argp2 = (Dali::PanGesture *)jarg2;
62350   if (!argp2) {
62351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
62352     return 0;
62353   }
62354   arg2 = *argp2;
62355   {
62356     try {
62357       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
62358     } catch (std::out_of_range& e) {
62359       {
62360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62361       };
62362     } catch (std::exception& e) {
62363       {
62364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62365       };
62366     } catch (...) {
62367       {
62368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62369       };
62370     }
62371   }
62372   jresult = result;
62373   return jresult;
62374 }
62375
62376
62377 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
62378   unsigned int jresult ;
62379   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62380   Dali::TouchEvent *arg2 = 0 ;
62381   bool result;
62382
62383   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62384   arg2 = (Dali::TouchEvent *)jarg2;
62385   if (!arg2) {
62386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
62387     return 0;
62388   }
62389   {
62390     try {
62391       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
62392     } catch (std::out_of_range& e) {
62393       {
62394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62395       };
62396     } catch (std::exception& e) {
62397       {
62398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62399       };
62400     } catch (...) {
62401       {
62402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62403       };
62404     }
62405   }
62406   jresult = result;
62407   return jresult;
62408 }
62409
62410
62411 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62412   unsigned int jresult ;
62413   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62414   Dali::TouchEvent *arg2 = 0 ;
62415   bool result;
62416
62417   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62418   arg2 = (Dali::TouchEvent *)jarg2;
62419   if (!arg2) {
62420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
62421     return 0;
62422   }
62423   {
62424     try {
62425       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
62426     } catch (std::out_of_range& e) {
62427       {
62428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62429       };
62430     } catch (std::exception& e) {
62431       {
62432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62433       };
62434     } catch (...) {
62435       {
62436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62437       };
62438     }
62439   }
62440   jresult = result;
62441   return jresult;
62442 }
62443
62444
62445 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
62446   unsigned int jresult ;
62447   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62448   bool arg2 ;
62449   bool result;
62450
62451   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62452   arg2 = jarg2 ? true : false;
62453   {
62454     try {
62455       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
62456     } catch (std::out_of_range& e) {
62457       {
62458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62459       };
62460     } catch (std::exception& e) {
62461       {
62462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62463       };
62464     } catch (...) {
62465       {
62466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62467       };
62468     }
62469   }
62470   jresult = result;
62471   return jresult;
62472 }
62473
62474
62475 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
62476   unsigned int jresult ;
62477   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62478   bool arg2 ;
62479   bool result;
62480
62481   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62482   arg2 = jarg2 ? true : false;
62483   {
62484     try {
62485       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
62486     } catch (std::out_of_range& e) {
62487       {
62488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62489       };
62490     } catch (std::exception& e) {
62491       {
62492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62493       };
62494     } catch (...) {
62495       {
62496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62497       };
62498     }
62499   }
62500   jresult = result;
62501   return jresult;
62502 }
62503
62504
62505 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
62506   unsigned int jresult ;
62507   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62508   bool result;
62509
62510   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62511   {
62512     try {
62513       result = (bool)(arg1)->OnAccessibilityZoom();
62514     } catch (std::out_of_range& e) {
62515       {
62516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62517       };
62518     } catch (std::exception& e) {
62519       {
62520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62521       };
62522     } catch (...) {
62523       {
62524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62525       };
62526     }
62527   }
62528   jresult = result;
62529   return jresult;
62530 }
62531
62532
62533 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
62534   unsigned int jresult ;
62535   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62536   bool result;
62537
62538   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62539   {
62540     try {
62541       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
62542     } catch (std::out_of_range& e) {
62543       {
62544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62545       };
62546     } catch (std::exception& e) {
62547       {
62548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62549       };
62550     } catch (...) {
62551       {
62552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62553       };
62554     }
62555   }
62556   jresult = result;
62557   return jresult;
62558 }
62559
62560
62561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
62562   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62563
62564   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62565   {
62566     try {
62567       (arg1)->OnKeyInputFocusGained();
62568     } catch (std::out_of_range& e) {
62569       {
62570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62571       };
62572     } catch (std::exception& e) {
62573       {
62574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62575       };
62576     } catch (...) {
62577       {
62578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62579       };
62580     }
62581   }
62582 }
62583
62584
62585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
62586   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62587
62588   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62589   {
62590     try {
62591       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
62592     } catch (std::out_of_range& e) {
62593       {
62594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62595       };
62596     } catch (std::exception& e) {
62597       {
62598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62599       };
62600     } catch (...) {
62601       {
62602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62603       };
62604     }
62605   }
62606 }
62607
62608
62609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
62610   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62611
62612   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62613   {
62614     try {
62615       (arg1)->OnKeyInputFocusLost();
62616     } catch (std::out_of_range& e) {
62617       {
62618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62619       };
62620     } catch (std::exception& e) {
62621       {
62622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62623       };
62624     } catch (...) {
62625       {
62626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62627       };
62628     }
62629   }
62630 }
62631
62632
62633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
62634   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62635
62636   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62637   {
62638     try {
62639       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
62640     } catch (std::out_of_range& e) {
62641       {
62642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62643       };
62644     } catch (std::exception& e) {
62645       {
62646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62647       };
62648     } catch (...) {
62649       {
62650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62651       };
62652     }
62653   }
62654 }
62655
62656
62657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62658   void * jresult ;
62659   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62660   Dali::Actor arg2 ;
62661   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62662   bool arg4 ;
62663   Dali::Actor *argp2 ;
62664   Dali::Actor result;
62665
62666   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62667   argp2 = (Dali::Actor *)jarg2;
62668   if (!argp2) {
62669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62670     return 0;
62671   }
62672   arg2 = *argp2;
62673   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62674   arg4 = jarg4 ? true : false;
62675   {
62676     try {
62677       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62678     } catch (std::out_of_range& e) {
62679       {
62680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62681       };
62682     } catch (std::exception& e) {
62683       {
62684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62685       };
62686     } catch (...) {
62687       {
62688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62689       };
62690     }
62691   }
62692   jresult = new Dali::Actor((const Dali::Actor &)result);
62693   return jresult;
62694 }
62695
62696
62697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62698   void * jresult ;
62699   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62700   Dali::Actor arg2 ;
62701   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62702   bool arg4 ;
62703   Dali::Actor *argp2 ;
62704   Dali::Actor result;
62705
62706   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62707   argp2 = (Dali::Actor *)jarg2;
62708   if (!argp2) {
62709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62710     return 0;
62711   }
62712   arg2 = *argp2;
62713   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62714   arg4 = jarg4 ? true : false;
62715   {
62716     try {
62717       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62718     } catch (std::out_of_range& e) {
62719       {
62720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62721       };
62722     } catch (std::exception& e) {
62723       {
62724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62725       };
62726     } catch (...) {
62727       {
62728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62729       };
62730     }
62731   }
62732   jresult = new Dali::Actor((const Dali::Actor &)result);
62733   return jresult;
62734 }
62735
62736
62737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
62738   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62739   Dali::Actor arg2 ;
62740   Dali::Actor *argp2 ;
62741
62742   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62743   argp2 = (Dali::Actor *)jarg2;
62744   if (!argp2) {
62745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62746     return ;
62747   }
62748   arg2 = *argp2;
62749   {
62750     try {
62751       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
62752     } catch (std::out_of_range& e) {
62753       {
62754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62755       };
62756     } catch (std::exception& e) {
62757       {
62758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62759       };
62760     } catch (...) {
62761       {
62762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62763       };
62764     }
62765   }
62766 }
62767
62768
62769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62770   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62771   Dali::Actor arg2 ;
62772   Dali::Actor *argp2 ;
62773
62774   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62775   argp2 = (Dali::Actor *)jarg2;
62776   if (!argp2) {
62777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62778     return ;
62779   }
62780   arg2 = *argp2;
62781   {
62782     try {
62783       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
62784     } catch (std::out_of_range& e) {
62785       {
62786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62787       };
62788     } catch (std::exception& e) {
62789       {
62790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62791       };
62792     } catch (...) {
62793       {
62794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62795       };
62796     }
62797   }
62798 }
62799
62800
62801 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
62802   unsigned int jresult ;
62803   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62804   bool result;
62805
62806   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62807   {
62808     try {
62809       result = (bool)(arg1)->OnKeyboardEnter();
62810     } catch (std::out_of_range& e) {
62811       {
62812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62813       };
62814     } catch (std::exception& e) {
62815       {
62816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62817       };
62818     } catch (...) {
62819       {
62820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62821       };
62822     }
62823   }
62824   jresult = result;
62825   return jresult;
62826 }
62827
62828
62829 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
62830   unsigned int jresult ;
62831   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62832   bool result;
62833
62834   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62835   {
62836     try {
62837       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
62838     } catch (std::out_of_range& e) {
62839       {
62840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62841       };
62842     } catch (std::exception& e) {
62843       {
62844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62845       };
62846     } catch (...) {
62847       {
62848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62849       };
62850     }
62851   }
62852   jresult = result;
62853   return jresult;
62854 }
62855
62856
62857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
62858   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62859   Dali::PinchGesture *arg2 = 0 ;
62860
62861   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62862   arg2 = (Dali::PinchGesture *)jarg2;
62863   if (!arg2) {
62864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62865     return ;
62866   }
62867   {
62868     try {
62869       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
62870     } catch (std::out_of_range& e) {
62871       {
62872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62873       };
62874     } catch (std::exception& e) {
62875       {
62876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62877       };
62878     } catch (...) {
62879       {
62880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62881       };
62882     }
62883   }
62884 }
62885
62886
62887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62888   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62889   Dali::PinchGesture *arg2 = 0 ;
62890
62891   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62892   arg2 = (Dali::PinchGesture *)jarg2;
62893   if (!arg2) {
62894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62895     return ;
62896   }
62897   {
62898     try {
62899       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
62900     } catch (std::out_of_range& e) {
62901       {
62902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62903       };
62904     } catch (std::exception& e) {
62905       {
62906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62907       };
62908     } catch (...) {
62909       {
62910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62911       };
62912     }
62913   }
62914 }
62915
62916
62917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
62918   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62919   Dali::PanGesture *arg2 = 0 ;
62920
62921   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62922   arg2 = (Dali::PanGesture *)jarg2;
62923   if (!arg2) {
62924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62925     return ;
62926   }
62927   {
62928     try {
62929       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
62930     } catch (std::out_of_range& e) {
62931       {
62932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62933       };
62934     } catch (std::exception& e) {
62935       {
62936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62937       };
62938     } catch (...) {
62939       {
62940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62941       };
62942     }
62943   }
62944 }
62945
62946
62947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62948   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62949   Dali::PanGesture *arg2 = 0 ;
62950
62951   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62952   arg2 = (Dali::PanGesture *)jarg2;
62953   if (!arg2) {
62954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62955     return ;
62956   }
62957   {
62958     try {
62959       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
62960     } catch (std::out_of_range& e) {
62961       {
62962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62963       };
62964     } catch (std::exception& e) {
62965       {
62966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62967       };
62968     } catch (...) {
62969       {
62970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62971       };
62972     }
62973   }
62974 }
62975
62976
62977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
62978   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62979   Dali::TapGesture *arg2 = 0 ;
62980
62981   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62982   arg2 = (Dali::TapGesture *)jarg2;
62983   if (!arg2) {
62984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
62985     return ;
62986   }
62987   {
62988     try {
62989       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
62990     } catch (std::out_of_range& e) {
62991       {
62992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62993       };
62994     } catch (std::exception& e) {
62995       {
62996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62997       };
62998     } catch (...) {
62999       {
63000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63001       };
63002     }
63003   }
63004 }
63005
63006
63007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63008   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63009   Dali::TapGesture *arg2 = 0 ;
63010
63011   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63012   arg2 = (Dali::TapGesture *)jarg2;
63013   if (!arg2) {
63014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
63015     return ;
63016   }
63017   {
63018     try {
63019       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
63020     } catch (std::out_of_range& e) {
63021       {
63022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63023       };
63024     } catch (std::exception& e) {
63025       {
63026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63027       };
63028     } catch (...) {
63029       {
63030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63031       };
63032     }
63033   }
63034 }
63035
63036
63037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
63038   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63039   Dali::LongPressGesture *arg2 = 0 ;
63040
63041   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63042   arg2 = (Dali::LongPressGesture *)jarg2;
63043   if (!arg2) {
63044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
63045     return ;
63046   }
63047   {
63048     try {
63049       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
63050     } catch (std::out_of_range& e) {
63051       {
63052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63053       };
63054     } catch (std::exception& e) {
63055       {
63056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63057       };
63058     } catch (...) {
63059       {
63060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63061       };
63062     }
63063   }
63064 }
63065
63066
63067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63068   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63069   Dali::LongPressGesture *arg2 = 0 ;
63070
63071   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63072   arg2 = (Dali::LongPressGesture *)jarg2;
63073   if (!arg2) {
63074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
63075     return ;
63076   }
63077   {
63078     try {
63079       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
63080     } catch (std::out_of_range& e) {
63081       {
63082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63083       };
63084     } catch (std::exception& e) {
63085       {
63086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63087       };
63088     } catch (...) {
63089       {
63090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63091       };
63092     }
63093   }
63094 }
63095
63096
63097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
63098   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63099   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63100   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63101
63102   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63103   arg2 = (Dali::SlotObserver *)jarg2;
63104   arg3 = (Dali::CallbackBase *)jarg3;
63105   {
63106     try {
63107       (arg1)->SignalConnected(arg2,arg3);
63108     } catch (std::out_of_range& e) {
63109       {
63110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63111       };
63112     } catch (std::exception& e) {
63113       {
63114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63115       };
63116     } catch (...) {
63117       {
63118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63119       };
63120     }
63121   }
63122 }
63123
63124
63125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
63126   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63127   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63128   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63129
63130   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63131   arg2 = (Dali::SlotObserver *)jarg2;
63132   arg3 = (Dali::CallbackBase *)jarg3;
63133   {
63134     try {
63135       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
63136     } catch (std::out_of_range& e) {
63137       {
63138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63139       };
63140     } catch (std::exception& e) {
63141       {
63142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63143       };
63144     } catch (...) {
63145       {
63146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63147       };
63148     }
63149   }
63150 }
63151
63152
63153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
63154   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63155   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63156   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63157
63158   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63159   arg2 = (Dali::SlotObserver *)jarg2;
63160   arg3 = (Dali::CallbackBase *)jarg3;
63161   {
63162     try {
63163       (arg1)->SignalDisconnected(arg2,arg3);
63164     } catch (std::out_of_range& e) {
63165       {
63166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63167       };
63168     } catch (std::exception& e) {
63169       {
63170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63171       };
63172     } catch (...) {
63173       {
63174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63175       };
63176     }
63177   }
63178 }
63179
63180
63181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
63182   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63183   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63184   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63185
63186   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63187   arg2 = (Dali::SlotObserver *)jarg2;
63188   arg3 = (Dali::CallbackBase *)jarg3;
63189   {
63190     try {
63191       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
63192     } catch (std::out_of_range& e) {
63193       {
63194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63195       };
63196     } catch (std::exception& e) {
63197       {
63198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63199       };
63200     } catch (...) {
63201       {
63202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63203       };
63204     }
63205   }
63206 }
63207
63208
63209 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) {
63210   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
63211   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
63212   if (director) {
63213     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);
63214   }
63215 }
63216
63217
63218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
63219   void * jresult ;
63220   Dali::Toolkit::Control *arg1 = 0 ;
63221   Dali::Toolkit::Internal::Control *result = 0 ;
63222
63223   arg1 = (Dali::Toolkit::Control *)jarg1;
63224   if (!arg1) {
63225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63226     return 0;
63227   }
63228   {
63229     try {
63230       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
63231     } catch (std::out_of_range& e) {
63232       {
63233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63234       };
63235     } catch (std::exception& e) {
63236       {
63237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63238       };
63239     } catch (...) {
63240       {
63241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63242       };
63243     }
63244   }
63245   jresult = (void *)result;
63246   return jresult;
63247 }
63248
63249
63250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
63251   int jresult ;
63252   int result;
63253
63254   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
63255   jresult = (int)result;
63256   return jresult;
63257 }
63258
63259
63260 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
63261   int jresult ;
63262   int result;
63263
63264   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
63265   jresult = (int)result;
63266   return jresult;
63267 }
63268
63269
63270 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
63271   int jresult ;
63272   int result;
63273
63274   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
63275   jresult = (int)result;
63276   return jresult;
63277 }
63278
63279
63280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
63281   int jresult ;
63282   int result;
63283
63284   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
63285   jresult = (int)result;
63286   return jresult;
63287 }
63288
63289
63290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
63291   int jresult ;
63292   int result;
63293
63294   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
63295   jresult = (int)result;
63296   return jresult;
63297 }
63298
63299
63300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
63301   void * jresult ;
63302   Dali::Toolkit::Control::Property *result = 0 ;
63303
63304   {
63305     try {
63306       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
63307     } catch (std::out_of_range& e) {
63308       {
63309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63310       };
63311     } catch (std::exception& e) {
63312       {
63313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63314       };
63315     } catch (...) {
63316       {
63317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63318       };
63319     }
63320   }
63321   jresult = (void *)result;
63322   return jresult;
63323 }
63324
63325
63326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
63327   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
63328
63329   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
63330   {
63331     try {
63332       delete arg1;
63333     } catch (std::out_of_range& e) {
63334       {
63335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63336       };
63337     } catch (std::exception& e) {
63338       {
63339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63340       };
63341     } catch (...) {
63342       {
63343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63344       };
63345     }
63346   }
63347 }
63348
63349
63350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
63351   void * jresult ;
63352   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
63353
63354   {
63355     try {
63356       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
63357     } catch (std::out_of_range& e) {
63358       {
63359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63360       };
63361     } catch (std::exception& e) {
63362       {
63363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63364       };
63365     } catch (...) {
63366       {
63367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63368       };
63369     }
63370   }
63371   jresult = (void *)result;
63372   return jresult;
63373 }
63374
63375
63376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
63377   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
63378
63379   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
63380   {
63381     try {
63382       delete arg1;
63383     } catch (std::out_of_range& e) {
63384       {
63385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63386       };
63387     } catch (std::exception& e) {
63388       {
63389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63390       };
63391     } catch (...) {
63392       {
63393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63394       };
63395     }
63396   }
63397 }
63398
63399
63400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
63401   void * jresult ;
63402   Dali::Toolkit::Control result;
63403
63404   {
63405     try {
63406       result = Dali::Toolkit::Control::New();
63407     } catch (std::out_of_range& e) {
63408       {
63409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63410       };
63411     } catch (std::exception& e) {
63412       {
63413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63414       };
63415     } catch (...) {
63416       {
63417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63418       };
63419     }
63420   }
63421   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63422   return jresult;
63423 }
63424
63425
63426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
63427   void * jresult ;
63428   Dali::Toolkit::Control *result = 0 ;
63429
63430   {
63431     try {
63432       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
63433     } catch (std::out_of_range& e) {
63434       {
63435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63436       };
63437     } catch (std::exception& e) {
63438       {
63439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63440       };
63441     } catch (...) {
63442       {
63443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63444       };
63445     }
63446   }
63447   jresult = (void *)result;
63448   return jresult;
63449 }
63450
63451
63452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
63453   void * jresult ;
63454   Dali::Toolkit::Control *arg1 = 0 ;
63455   Dali::Toolkit::Control *result = 0 ;
63456
63457   arg1 = (Dali::Toolkit::Control *)jarg1;
63458   if (!arg1) {
63459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63460     return 0;
63461   }
63462   {
63463     try {
63464       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
63465     } catch (std::out_of_range& e) {
63466       {
63467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63468       };
63469     } catch (std::exception& e) {
63470       {
63471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63472       };
63473     } catch (...) {
63474       {
63475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63476       };
63477     }
63478   }
63479   jresult = (void *)result;
63480   return jresult;
63481 }
63482
63483
63484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
63485   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63486
63487   arg1 = (Dali::Toolkit::Control *)jarg1;
63488   {
63489     try {
63490       delete arg1;
63491     } catch (std::out_of_range& e) {
63492       {
63493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63494       };
63495     } catch (std::exception& e) {
63496       {
63497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63498       };
63499     } catch (...) {
63500       {
63501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63502       };
63503     }
63504   }
63505 }
63506
63507
63508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
63509   void * jresult ;
63510   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63511   Dali::Toolkit::Control *arg2 = 0 ;
63512   Dali::Toolkit::Control *result = 0 ;
63513
63514   arg1 = (Dali::Toolkit::Control *)jarg1;
63515   arg2 = (Dali::Toolkit::Control *)jarg2;
63516   if (!arg2) {
63517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63518     return 0;
63519   }
63520   {
63521     try {
63522       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
63523     } catch (std::out_of_range& e) {
63524       {
63525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63526       };
63527     } catch (std::exception& e) {
63528       {
63529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63530       };
63531     } catch (...) {
63532       {
63533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63534       };
63535     }
63536   }
63537   jresult = (void *)result;
63538   return jresult;
63539 }
63540
63541
63542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
63543   void * jresult ;
63544   Dali::BaseHandle arg1 ;
63545   Dali::BaseHandle *argp1 ;
63546   Dali::Toolkit::Control result;
63547
63548   argp1 = (Dali::BaseHandle *)jarg1;
63549   if (!argp1) {
63550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63551     return 0;
63552   }
63553   arg1 = *argp1;
63554   {
63555     try {
63556       result = Dali::Toolkit::Control::DownCast(arg1);
63557     } catch (std::out_of_range& e) {
63558       {
63559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63560       };
63561     } catch (std::exception& e) {
63562       {
63563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63564       };
63565     } catch (...) {
63566       {
63567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63568       };
63569     }
63570   }
63571   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63572   return jresult;
63573 }
63574
63575
63576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
63577   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63578
63579   arg1 = (Dali::Toolkit::Control *)jarg1;
63580   {
63581     try {
63582       (arg1)->SetKeyInputFocus();
63583     } catch (std::out_of_range& e) {
63584       {
63585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63586       };
63587     } catch (std::exception& e) {
63588       {
63589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63590       };
63591     } catch (...) {
63592       {
63593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63594       };
63595     }
63596   }
63597 }
63598
63599
63600 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
63601   unsigned int jresult ;
63602   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63603   bool result;
63604
63605   arg1 = (Dali::Toolkit::Control *)jarg1;
63606   {
63607     try {
63608       result = (bool)(arg1)->HasKeyInputFocus();
63609     } catch (std::out_of_range& e) {
63610       {
63611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63612       };
63613     } catch (std::exception& e) {
63614       {
63615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63616       };
63617     } catch (...) {
63618       {
63619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63620       };
63621     }
63622   }
63623   jresult = result;
63624   return jresult;
63625 }
63626
63627
63628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
63629   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63630
63631   arg1 = (Dali::Toolkit::Control *)jarg1;
63632   {
63633     try {
63634       (arg1)->ClearKeyInputFocus();
63635     } catch (std::out_of_range& e) {
63636       {
63637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63638       };
63639     } catch (std::exception& e) {
63640       {
63641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63642       };
63643     } catch (...) {
63644       {
63645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63646       };
63647     }
63648   }
63649 }
63650
63651
63652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
63653   void * jresult ;
63654   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63655   Dali::PinchGestureDetector result;
63656
63657   arg1 = (Dali::Toolkit::Control *)jarg1;
63658   {
63659     try {
63660       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
63661     } catch (std::out_of_range& e) {
63662       {
63663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63664       };
63665     } catch (std::exception& e) {
63666       {
63667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63668       };
63669     } catch (...) {
63670       {
63671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63672       };
63673     }
63674   }
63675   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63676   return jresult;
63677 }
63678
63679
63680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
63681   void * jresult ;
63682   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63683   Dali::PanGestureDetector result;
63684
63685   arg1 = (Dali::Toolkit::Control *)jarg1;
63686   {
63687     try {
63688       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
63689     } catch (std::out_of_range& e) {
63690       {
63691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63692       };
63693     } catch (std::exception& e) {
63694       {
63695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63696       };
63697     } catch (...) {
63698       {
63699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63700       };
63701     }
63702   }
63703   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63704   return jresult;
63705 }
63706
63707
63708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
63709   void * jresult ;
63710   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63711   Dali::TapGestureDetector result;
63712
63713   arg1 = (Dali::Toolkit::Control *)jarg1;
63714   {
63715     try {
63716       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
63717     } catch (std::out_of_range& e) {
63718       {
63719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63720       };
63721     } catch (std::exception& e) {
63722       {
63723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63724       };
63725     } catch (...) {
63726       {
63727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63728       };
63729     }
63730   }
63731   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63732   return jresult;
63733 }
63734
63735
63736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
63737   void * jresult ;
63738   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63739   Dali::LongPressGestureDetector result;
63740
63741   arg1 = (Dali::Toolkit::Control *)jarg1;
63742   {
63743     try {
63744       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
63745     } catch (std::out_of_range& e) {
63746       {
63747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63748       };
63749     } catch (std::exception& e) {
63750       {
63751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63752       };
63753     } catch (...) {
63754       {
63755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63756       };
63757     }
63758   }
63759   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63760   return jresult;
63761 }
63762
63763
63764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
63765   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63766   std::string *arg2 = 0 ;
63767
63768   arg1 = (Dali::Toolkit::Control *)jarg1;
63769   if (!jarg2) {
63770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63771     return ;
63772   }
63773   std::string arg2_str(jarg2);
63774   arg2 = &arg2_str;
63775   {
63776     try {
63777       (arg1)->SetStyleName((std::string const &)*arg2);
63778     } catch (std::out_of_range& e) {
63779       {
63780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63781       };
63782     } catch (std::exception& e) {
63783       {
63784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63785       };
63786     } catch (...) {
63787       {
63788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63789       };
63790     }
63791   }
63792
63793   //argout typemap for const std::string&
63794
63795 }
63796
63797
63798 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
63799   char * jresult ;
63800   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63801   std::string *result = 0 ;
63802
63803   arg1 = (Dali::Toolkit::Control *)jarg1;
63804   {
63805     try {
63806       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
63807     } catch (std::out_of_range& e) {
63808       {
63809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63810       };
63811     } catch (std::exception& e) {
63812       {
63813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63814       };
63815     } catch (...) {
63816       {
63817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63818       };
63819     }
63820   }
63821   jresult = SWIG_csharp_string_callback(result->c_str());
63822   return jresult;
63823 }
63824
63825
63826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
63827   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63828   Dali::Vector4 *arg2 = 0 ;
63829
63830   arg1 = (Dali::Toolkit::Control *)jarg1;
63831   arg2 = (Dali::Vector4 *)jarg2;
63832   if (!arg2) {
63833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63834     return ;
63835   }
63836   {
63837     try {
63838       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63839     } catch (std::out_of_range& e) {
63840       {
63841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63842       };
63843     } catch (std::exception& e) {
63844       {
63845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63846       };
63847     } catch (...) {
63848       {
63849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63850       };
63851     }
63852   }
63853 }
63854
63855
63856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
63857   void * jresult ;
63858   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63859   Dali::Vector4 result;
63860
63861   arg1 = (Dali::Toolkit::Control *)jarg1;
63862   {
63863     try {
63864       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
63865     } catch (std::out_of_range& e) {
63866       {
63867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63868       };
63869     } catch (std::exception& e) {
63870       {
63871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63872       };
63873     } catch (...) {
63874       {
63875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63876       };
63877     }
63878   }
63879   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63880   return jresult;
63881 }
63882
63883
63884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
63885   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63886   Dali::Image arg2 ;
63887   Dali::Image *argp2 ;
63888
63889   arg1 = (Dali::Toolkit::Control *)jarg1;
63890   argp2 = (Dali::Image *)jarg2;
63891   if (!argp2) {
63892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63893     return ;
63894   }
63895   arg2 = *argp2;
63896   {
63897     try {
63898       (arg1)->SetBackgroundImage(arg2);
63899     } catch (std::out_of_range& e) {
63900       {
63901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63902       };
63903     } catch (std::exception& e) {
63904       {
63905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63906       };
63907     } catch (...) {
63908       {
63909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63910       };
63911     }
63912   }
63913 }
63914
63915
63916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
63917   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63918
63919   arg1 = (Dali::Toolkit::Control *)jarg1;
63920   {
63921     try {
63922       (arg1)->ClearBackground();
63923     } catch (std::out_of_range& e) {
63924       {
63925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63926       };
63927     } catch (std::exception& e) {
63928       {
63929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63930       };
63931     } catch (...) {
63932       {
63933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63934       };
63935     }
63936   }
63937 }
63938
63939
63940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
63941   void * jresult ;
63942   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63943   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63944
63945   arg1 = (Dali::Toolkit::Control *)jarg1;
63946   {
63947     try {
63948       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63949     } catch (std::out_of_range& e) {
63950       {
63951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63952       };
63953     } catch (std::exception& e) {
63954       {
63955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63956       };
63957     } catch (...) {
63958       {
63959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63960       };
63961     }
63962   }
63963   jresult = (void *)result;
63964   return jresult;
63965 }
63966
63967
63968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
63969   void * jresult ;
63970   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63971   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63972
63973   arg1 = (Dali::Toolkit::Control *)jarg1;
63974   {
63975     try {
63976       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
63977     } catch (std::out_of_range& e) {
63978       {
63979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63980       };
63981     } catch (std::exception& e) {
63982       {
63983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63984       };
63985     } catch (...) {
63986       {
63987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63988       };
63989     }
63990   }
63991   jresult = (void *)result;
63992   return jresult;
63993 }
63994
63995
63996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
63997   void * jresult ;
63998   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63999   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64000
64001   arg1 = (Dali::Toolkit::Control *)jarg1;
64002   {
64003     try {
64004       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
64005     } catch (std::out_of_range& e) {
64006       {
64007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64008       };
64009     } catch (std::exception& e) {
64010       {
64011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64012       };
64013     } catch (...) {
64014       {
64015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64016       };
64017     }
64018   }
64019   jresult = (void *)result;
64020   return jresult;
64021 }
64022
64023
64024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
64025   void * jresult ;
64026   Dali::Toolkit::Internal::Control *arg1 = 0 ;
64027   Dali::Toolkit::Control *result = 0 ;
64028
64029   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64030   if (!arg1) {
64031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
64032     return 0;
64033   }
64034   {
64035     try {
64036       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
64037     } catch (std::out_of_range& e) {
64038       {
64039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64040       };
64041     } catch (std::exception& e) {
64042       {
64043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64044       };
64045     } catch (...) {
64046       {
64047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64048       };
64049     }
64050   }
64051   jresult = (void *)result;
64052   return jresult;
64053 }
64054
64055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
64056   void * jresult ;
64057   Dali::Toolkit::Control *arg1 = 0 ;
64058   Dali::Toolkit::DevelControl::ResourceReadySignalType *result = 0 ;
64059
64060   arg1 = (Dali::Toolkit::Control *)jarg1;
64061   if (!arg1) {
64062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
64063     return 0;
64064   }
64065   {
64066     try {
64067       result = (Dali::Toolkit::DevelControl::ResourceReadySignalType *) &Dali::Toolkit::DevelControl::ResourceReadySignal(*arg1);
64068     } catch (std::out_of_range& e) {
64069       {
64070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64071       };
64072     } catch (std::exception& e) {
64073       {
64074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64075       };
64076     } catch (...) {
64077       {
64078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64079       };
64080     }
64081   }
64082   jresult = (void *)result;
64083   return jresult;
64084 }
64085
64086
64087 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
64088   unsigned int jresult ;
64089   Dali::Toolkit::Control *arg1 = 0 ;
64090   bool result;
64091
64092   arg1 = (Dali::Toolkit::Control *)jarg1;
64093   if (!arg1) {
64094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
64095     return 0;
64096   }
64097   {
64098     try {
64099       result = (bool)Dali::Toolkit::DevelControl::IsResourceReady((Dali::Toolkit::Control const &)*arg1);
64100     } catch (std::out_of_range& e) {
64101       {
64102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64103       };
64104     } catch (std::exception& e) {
64105       {
64106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64107       };
64108     } catch (...) {
64109       {
64110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64111       };
64112     }
64113   }
64114   jresult = result;
64115   return jresult;
64116 }
64117
64118
64119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
64120   void * jresult ;
64121   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
64122
64123   {
64124     try {
64125       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
64126     } catch (std::out_of_range& e) {
64127       {
64128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64129       };
64130     } catch (std::exception& e) {
64131       {
64132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64133       };
64134     } catch (...) {
64135       {
64136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64137       };
64138     }
64139   }
64140   jresult = (void *)result;
64141   return jresult;
64142 }
64143
64144
64145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
64146   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64147
64148   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64149   {
64150     try {
64151       delete arg1;
64152     } catch (std::out_of_range& e) {
64153       {
64154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64155       };
64156     } catch (std::exception& e) {
64157       {
64158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64159       };
64160     } catch (...) {
64161       {
64162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64163       };
64164     }
64165   }
64166 }
64167
64168
64169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
64170   void * jresult ;
64171   Dali::Toolkit::KeyInputFocusManager result;
64172
64173   {
64174     try {
64175       result = Dali::Toolkit::KeyInputFocusManager::Get();
64176     } catch (std::out_of_range& e) {
64177       {
64178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64179       };
64180     } catch (std::exception& e) {
64181       {
64182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64183       };
64184     } catch (...) {
64185       {
64186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64187       };
64188     }
64189   }
64190   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
64191   return jresult;
64192 }
64193
64194
64195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
64196   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64197   Dali::Toolkit::Control arg2 ;
64198   Dali::Toolkit::Control *argp2 ;
64199
64200   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64201   argp2 = (Dali::Toolkit::Control *)jarg2;
64202   if (!argp2) {
64203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
64204     return ;
64205   }
64206   arg2 = *argp2;
64207   {
64208     try {
64209       (arg1)->SetFocus(arg2);
64210     } catch (std::out_of_range& e) {
64211       {
64212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64213       };
64214     } catch (std::exception& e) {
64215       {
64216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64217       };
64218     } catch (...) {
64219       {
64220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64221       };
64222     }
64223   }
64224 }
64225
64226
64227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
64228   void * jresult ;
64229   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64230   Dali::Toolkit::Control result;
64231
64232   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64233   {
64234     try {
64235       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
64236     } catch (std::out_of_range& e) {
64237       {
64238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64239       };
64240     } catch (std::exception& e) {
64241       {
64242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64243       };
64244     } catch (...) {
64245       {
64246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64247       };
64248     }
64249   }
64250   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
64251   return jresult;
64252 }
64253
64254
64255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
64256   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64257   Dali::Toolkit::Control arg2 ;
64258   Dali::Toolkit::Control *argp2 ;
64259
64260   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64261   argp2 = (Dali::Toolkit::Control *)jarg2;
64262   if (!argp2) {
64263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
64264     return ;
64265   }
64266   arg2 = *argp2;
64267   {
64268     try {
64269       (arg1)->RemoveFocus(arg2);
64270     } catch (std::out_of_range& e) {
64271       {
64272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64273       };
64274     } catch (std::exception& e) {
64275       {
64276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64277       };
64278     } catch (...) {
64279       {
64280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64281       };
64282     }
64283   }
64284 }
64285
64286
64287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
64288   void * jresult ;
64289   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64290   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
64291
64292   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64293   {
64294     try {
64295       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
64296     } catch (std::out_of_range& e) {
64297       {
64298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64299       };
64300     } catch (std::exception& e) {
64301       {
64302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64303       };
64304     } catch (...) {
64305       {
64306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64307       };
64308     }
64309   }
64310   jresult = (void *)result;
64311   return jresult;
64312 }
64313
64314
64315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
64316   void * jresult ;
64317   Dali::Toolkit::Alignment::Padding *result = 0 ;
64318
64319   {
64320     try {
64321       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
64322     } catch (std::out_of_range& e) {
64323       {
64324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64325       };
64326     } catch (std::exception& e) {
64327       {
64328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64329       };
64330     } catch (...) {
64331       {
64332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64333       };
64334     }
64335   }
64336   jresult = (void *)result;
64337   return jresult;
64338 }
64339
64340
64341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
64342   void * jresult ;
64343   float arg1 ;
64344   float arg2 ;
64345   float arg3 ;
64346   float arg4 ;
64347   Dali::Toolkit::Alignment::Padding *result = 0 ;
64348
64349   arg1 = (float)jarg1;
64350   arg2 = (float)jarg2;
64351   arg3 = (float)jarg3;
64352   arg4 = (float)jarg4;
64353   {
64354     try {
64355       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
64356     } catch (std::out_of_range& e) {
64357       {
64358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64359       };
64360     } catch (std::exception& e) {
64361       {
64362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64363       };
64364     } catch (...) {
64365       {
64366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64367       };
64368     }
64369   }
64370   jresult = (void *)result;
64371   return jresult;
64372 }
64373
64374
64375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
64376   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64377   float arg2 ;
64378
64379   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64380   arg2 = (float)jarg2;
64381   if (arg1) (arg1)->left = arg2;
64382 }
64383
64384
64385 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
64386   float jresult ;
64387   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64388   float result;
64389
64390   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64391   result = (float) ((arg1)->left);
64392   jresult = result;
64393   return jresult;
64394 }
64395
64396
64397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
64398   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64399   float arg2 ;
64400
64401   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64402   arg2 = (float)jarg2;
64403   if (arg1) (arg1)->right = arg2;
64404 }
64405
64406
64407 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
64408   float jresult ;
64409   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64410   float result;
64411
64412   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64413   result = (float) ((arg1)->right);
64414   jresult = result;
64415   return jresult;
64416 }
64417
64418
64419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
64420   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64421   float arg2 ;
64422
64423   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64424   arg2 = (float)jarg2;
64425   if (arg1) (arg1)->top = arg2;
64426 }
64427
64428
64429 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
64430   float jresult ;
64431   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64432   float result;
64433
64434   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64435   result = (float) ((arg1)->top);
64436   jresult = result;
64437   return jresult;
64438 }
64439
64440
64441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
64442   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64443   float arg2 ;
64444
64445   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64446   arg2 = (float)jarg2;
64447   if (arg1) (arg1)->bottom = arg2;
64448 }
64449
64450
64451 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
64452   float jresult ;
64453   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64454   float result;
64455
64456   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64457   result = (float) ((arg1)->bottom);
64458   jresult = result;
64459   return jresult;
64460 }
64461
64462
64463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
64464   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64465
64466   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64467   {
64468     try {
64469       delete arg1;
64470     } catch (std::out_of_range& e) {
64471       {
64472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64473       };
64474     } catch (std::exception& e) {
64475       {
64476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64477       };
64478     } catch (...) {
64479       {
64480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64481       };
64482     }
64483   }
64484 }
64485
64486
64487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
64488   void * jresult ;
64489   Dali::Toolkit::Alignment *result = 0 ;
64490
64491   {
64492     try {
64493       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
64494     } catch (std::out_of_range& e) {
64495       {
64496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64497       };
64498     } catch (std::exception& e) {
64499       {
64500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64501       };
64502     } catch (...) {
64503       {
64504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64505       };
64506     }
64507   }
64508   jresult = (void *)result;
64509   return jresult;
64510 }
64511
64512
64513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
64514   void * jresult ;
64515   Dali::Toolkit::Alignment::Type arg1 ;
64516   Dali::Toolkit::Alignment::Type arg2 ;
64517   Dali::Toolkit::Alignment result;
64518
64519   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64520   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64521   {
64522     try {
64523       result = Dali::Toolkit::Alignment::New(arg1,arg2);
64524     } catch (std::out_of_range& e) {
64525       {
64526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64527       };
64528     } catch (std::exception& e) {
64529       {
64530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64531       };
64532     } catch (...) {
64533       {
64534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64535       };
64536     }
64537   }
64538   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64539   return jresult;
64540 }
64541
64542
64543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
64544   void * jresult ;
64545   Dali::Toolkit::Alignment::Type arg1 ;
64546   Dali::Toolkit::Alignment result;
64547
64548   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64549   {
64550     try {
64551       result = Dali::Toolkit::Alignment::New(arg1);
64552     } catch (std::out_of_range& e) {
64553       {
64554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64555       };
64556     } catch (std::exception& e) {
64557       {
64558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64559       };
64560     } catch (...) {
64561       {
64562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64563       };
64564     }
64565   }
64566   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64567   return jresult;
64568 }
64569
64570
64571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
64572   void * jresult ;
64573   Dali::Toolkit::Alignment result;
64574
64575   {
64576     try {
64577       result = Dali::Toolkit::Alignment::New();
64578     } catch (std::out_of_range& e) {
64579       {
64580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64581       };
64582     } catch (std::exception& e) {
64583       {
64584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64585       };
64586     } catch (...) {
64587       {
64588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64589       };
64590     }
64591   }
64592   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64593   return jresult;
64594 }
64595
64596
64597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
64598   void * jresult ;
64599   Dali::Toolkit::Alignment *arg1 = 0 ;
64600   Dali::Toolkit::Alignment *result = 0 ;
64601
64602   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64603   if (!arg1) {
64604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
64605     return 0;
64606   }
64607   {
64608     try {
64609       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
64610     } catch (std::out_of_range& e) {
64611       {
64612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64613       };
64614     } catch (std::exception& e) {
64615       {
64616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64617       };
64618     } catch (...) {
64619       {
64620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64621       };
64622     }
64623   }
64624   jresult = (void *)result;
64625   return jresult;
64626 }
64627
64628
64629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
64630   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64631
64632   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64633   {
64634     try {
64635       delete arg1;
64636     } catch (std::out_of_range& e) {
64637       {
64638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64639       };
64640     } catch (std::exception& e) {
64641       {
64642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64643       };
64644     } catch (...) {
64645       {
64646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64647       };
64648     }
64649   }
64650 }
64651
64652
64653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
64654   void * jresult ;
64655   Dali::BaseHandle arg1 ;
64656   Dali::BaseHandle *argp1 ;
64657   Dali::Toolkit::Alignment result;
64658
64659   argp1 = (Dali::BaseHandle *)jarg1;
64660   if (!argp1) {
64661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64662     return 0;
64663   }
64664   arg1 = *argp1;
64665   {
64666     try {
64667       result = Dali::Toolkit::Alignment::DownCast(arg1);
64668     } catch (std::out_of_range& e) {
64669       {
64670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64671       };
64672     } catch (std::exception& e) {
64673       {
64674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64675       };
64676     } catch (...) {
64677       {
64678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64679       };
64680     }
64681   }
64682   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64683   return jresult;
64684 }
64685
64686
64687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
64688   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64689   Dali::Toolkit::Alignment::Type arg2 ;
64690
64691   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64692   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64693   {
64694     try {
64695       (arg1)->SetAlignmentType(arg2);
64696     } catch (std::out_of_range& e) {
64697       {
64698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64699       };
64700     } catch (std::exception& e) {
64701       {
64702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64703       };
64704     } catch (...) {
64705       {
64706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64707       };
64708     }
64709   }
64710 }
64711
64712
64713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
64714   int jresult ;
64715   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64716   Dali::Toolkit::Alignment::Type result;
64717
64718   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64719   {
64720     try {
64721       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
64722     } catch (std::out_of_range& e) {
64723       {
64724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64725       };
64726     } catch (std::exception& e) {
64727       {
64728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64729       };
64730     } catch (...) {
64731       {
64732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64733       };
64734     }
64735   }
64736   jresult = (int)result;
64737   return jresult;
64738 }
64739
64740
64741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
64742   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64743   Dali::Toolkit::Alignment::Scaling arg2 ;
64744
64745   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64746   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
64747   {
64748     try {
64749       (arg1)->SetScaling(arg2);
64750     } catch (std::out_of_range& e) {
64751       {
64752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64753       };
64754     } catch (std::exception& e) {
64755       {
64756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64757       };
64758     } catch (...) {
64759       {
64760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64761       };
64762     }
64763   }
64764 }
64765
64766
64767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
64768   int jresult ;
64769   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64770   Dali::Toolkit::Alignment::Scaling result;
64771
64772   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64773   {
64774     try {
64775       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
64776     } catch (std::out_of_range& e) {
64777       {
64778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64779       };
64780     } catch (std::exception& e) {
64781       {
64782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64783       };
64784     } catch (...) {
64785       {
64786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64787       };
64788     }
64789   }
64790   jresult = (int)result;
64791   return jresult;
64792 }
64793
64794
64795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
64796   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64797   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
64798
64799   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64800   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
64801   if (!arg2) {
64802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
64803     return ;
64804   }
64805   {
64806     try {
64807       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
64808     } catch (std::out_of_range& e) {
64809       {
64810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64811       };
64812     } catch (std::exception& e) {
64813       {
64814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64815       };
64816     } catch (...) {
64817       {
64818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64819       };
64820     }
64821   }
64822 }
64823
64824
64825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
64826   void * jresult ;
64827   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64828   Dali::Toolkit::Alignment::Padding *result = 0 ;
64829
64830   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64831   {
64832     try {
64833       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
64834     } catch (std::out_of_range& e) {
64835       {
64836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64837       };
64838     } catch (std::exception& e) {
64839       {
64840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64841       };
64842     } catch (...) {
64843       {
64844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64845       };
64846     }
64847   }
64848   jresult = (void *)result;
64849   return jresult;
64850 }
64851
64852
64853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
64854   void * jresult ;
64855   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64856   Dali::Toolkit::Alignment *arg2 = 0 ;
64857   Dali::Toolkit::Alignment *result = 0 ;
64858
64859   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64860   arg2 = (Dali::Toolkit::Alignment *)jarg2;
64861   if (!arg2) {
64862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
64863     return 0;
64864   }
64865   {
64866     try {
64867       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
64868     } catch (std::out_of_range& e) {
64869       {
64870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64871       };
64872     } catch (std::exception& e) {
64873       {
64874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64875       };
64876     } catch (...) {
64877       {
64878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64879       };
64880     }
64881   }
64882   jresult = (void *)result;
64883   return jresult;
64884 }
64885
64886
64887 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
64888   int jresult ;
64889   int result;
64890
64891   result = (int)Dali::Toolkit::Button::Property::DISABLED;
64892   jresult = (int)result;
64893   return jresult;
64894 }
64895
64896
64897 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
64898   int jresult ;
64899   int result;
64900
64901   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
64902   jresult = (int)result;
64903   return jresult;
64904 }
64905
64906
64907 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
64908   int jresult ;
64909   int result;
64910
64911   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
64912   jresult = (int)result;
64913   return jresult;
64914 }
64915
64916
64917 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
64918   int jresult ;
64919   int result;
64920
64921   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
64922   jresult = (int)result;
64923   return jresult;
64924 }
64925
64926
64927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
64928   int jresult ;
64929   int result;
64930
64931   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
64932   jresult = (int)result;
64933   return jresult;
64934 }
64935
64936
64937 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
64938   int jresult ;
64939   int result;
64940
64941   result = (int)Dali::Toolkit::Button::Property::SELECTED;
64942   jresult = (int)result;
64943   return jresult;
64944 }
64945
64946
64947 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
64948   int jresult ;
64949   int result;
64950
64951   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
64952   jresult = (int)result;
64953   return jresult;
64954 }
64955
64956
64957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
64958   int jresult ;
64959   int result;
64960
64961   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
64962   jresult = (int)result;
64963   return jresult;
64964 }
64965
64966
64967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
64968   int jresult ;
64969   int result;
64970
64971   result = (int)Dali::Toolkit::Button::Property::LABEL;
64972   jresult = (int)result;
64973   return jresult;
64974 }
64975
64976
64977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
64978   int jresult ;
64979   int result;
64980
64981   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
64982   jresult = (int)result;
64983   return jresult;
64984 }
64985
64986
64987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
64988   void * jresult ;
64989   Dali::Toolkit::Button::Property *result = 0 ;
64990
64991   {
64992     try {
64993       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
64994     } catch (std::out_of_range& e) {
64995       {
64996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64997       };
64998     } catch (std::exception& e) {
64999       {
65000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65001       };
65002     } catch (...) {
65003       {
65004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65005       };
65006     }
65007   }
65008   jresult = (void *)result;
65009   return jresult;
65010 }
65011
65012
65013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
65014   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
65015
65016   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
65017   {
65018     try {
65019       delete arg1;
65020     } catch (std::out_of_range& e) {
65021       {
65022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65023       };
65024     } catch (std::exception& e) {
65025       {
65026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65027       };
65028     } catch (...) {
65029       {
65030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65031       };
65032     }
65033   }
65034 }
65035
65036
65037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
65038   void * jresult ;
65039   Dali::Toolkit::Button *result = 0 ;
65040
65041   {
65042     try {
65043       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
65044     } catch (std::out_of_range& e) {
65045       {
65046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65047       };
65048     } catch (std::exception& e) {
65049       {
65050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65051       };
65052     } catch (...) {
65053       {
65054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65055       };
65056     }
65057   }
65058   jresult = (void *)result;
65059   return jresult;
65060 }
65061
65062
65063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
65064   void * jresult ;
65065   Dali::Toolkit::Button *arg1 = 0 ;
65066   Dali::Toolkit::Button *result = 0 ;
65067
65068   arg1 = (Dali::Toolkit::Button *)jarg1;
65069   if (!arg1) {
65070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
65071     return 0;
65072   }
65073   {
65074     try {
65075       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
65076     } catch (std::out_of_range& e) {
65077       {
65078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65079       };
65080     } catch (std::exception& e) {
65081       {
65082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65083       };
65084     } catch (...) {
65085       {
65086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65087       };
65088     }
65089   }
65090   jresult = (void *)result;
65091   return jresult;
65092 }
65093
65094
65095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
65096   void * jresult ;
65097   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65098   Dali::Toolkit::Button *arg2 = 0 ;
65099   Dali::Toolkit::Button *result = 0 ;
65100
65101   arg1 = (Dali::Toolkit::Button *)jarg1;
65102   arg2 = (Dali::Toolkit::Button *)jarg2;
65103   if (!arg2) {
65104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
65105     return 0;
65106   }
65107   {
65108     try {
65109       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
65110     } catch (std::out_of_range& e) {
65111       {
65112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65113       };
65114     } catch (std::exception& e) {
65115       {
65116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65117       };
65118     } catch (...) {
65119       {
65120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65121       };
65122     }
65123   }
65124   jresult = (void *)result;
65125   return jresult;
65126 }
65127
65128
65129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
65130   void * jresult ;
65131   Dali::BaseHandle arg1 ;
65132   Dali::BaseHandle *argp1 ;
65133   Dali::Toolkit::Button result;
65134
65135   argp1 = (Dali::BaseHandle *)jarg1;
65136   if (!argp1) {
65137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65138     return 0;
65139   }
65140   arg1 = *argp1;
65141   {
65142     try {
65143       result = Dali::Toolkit::Button::DownCast(arg1);
65144     } catch (std::out_of_range& e) {
65145       {
65146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65147       };
65148     } catch (std::exception& e) {
65149       {
65150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65151       };
65152     } catch (...) {
65153       {
65154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65155       };
65156     }
65157   }
65158   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
65159   return jresult;
65160 }
65161
65162
65163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
65164   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65165
65166   arg1 = (Dali::Toolkit::Button *)jarg1;
65167   {
65168     try {
65169       delete arg1;
65170     } catch (std::out_of_range& e) {
65171       {
65172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65173       };
65174     } catch (std::exception& e) {
65175       {
65176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65177       };
65178     } catch (...) {
65179       {
65180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65181       };
65182     }
65183   }
65184 }
65185
65186
65187 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
65188   unsigned int jresult ;
65189   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65190   bool result;
65191
65192   arg1 = (Dali::Toolkit::Button *)jarg1;
65193   {
65194     try {
65195       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
65196     } catch (std::out_of_range& e) {
65197       {
65198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65199       };
65200     } catch (std::exception& e) {
65201       {
65202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65203       };
65204     } catch (...) {
65205       {
65206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65207       };
65208     }
65209   }
65210   jresult = result;
65211   return jresult;
65212 }
65213
65214
65215 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
65216   unsigned int jresult ;
65217   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65218   bool result;
65219
65220   arg1 = (Dali::Toolkit::Button *)jarg1;
65221   {
65222     try {
65223       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
65224     } catch (std::out_of_range& e) {
65225       {
65226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65227       };
65228     } catch (std::exception& e) {
65229       {
65230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65231       };
65232     } catch (...) {
65233       {
65234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65235       };
65236     }
65237   }
65238   jresult = result;
65239   return jresult;
65240 }
65241
65242
65243 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
65244   float jresult ;
65245   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65246   float result;
65247
65248   arg1 = (Dali::Toolkit::Button *)jarg1;
65249   {
65250     try {
65251       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
65252     } catch (std::out_of_range& e) {
65253       {
65254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65255       };
65256     } catch (std::exception& e) {
65257       {
65258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65259       };
65260     } catch (...) {
65261       {
65262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65263       };
65264     }
65265   }
65266   jresult = result;
65267   return jresult;
65268 }
65269
65270
65271 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
65272   float jresult ;
65273   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65274   float result;
65275
65276   arg1 = (Dali::Toolkit::Button *)jarg1;
65277   {
65278     try {
65279       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
65280     } catch (std::out_of_range& e) {
65281       {
65282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65283       };
65284     } catch (std::exception& e) {
65285       {
65286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65287       };
65288     } catch (...) {
65289       {
65290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65291       };
65292     }
65293   }
65294   jresult = result;
65295   return jresult;
65296 }
65297
65298
65299 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
65300   unsigned int jresult ;
65301   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65302   bool result;
65303
65304   arg1 = (Dali::Toolkit::Button *)jarg1;
65305   {
65306     try {
65307       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
65308     } catch (std::out_of_range& e) {
65309       {
65310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65311       };
65312     } catch (std::exception& e) {
65313       {
65314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65315       };
65316     } catch (...) {
65317       {
65318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65319       };
65320     }
65321   }
65322   jresult = result;
65323   return jresult;
65324 }
65325
65326
65327 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
65328   unsigned int jresult ;
65329   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65330   bool result;
65331
65332   arg1 = (Dali::Toolkit::Button *)jarg1;
65333   {
65334     try {
65335       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
65336     } catch (std::out_of_range& e) {
65337       {
65338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65339       };
65340     } catch (std::exception& e) {
65341       {
65342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65343       };
65344     } catch (...) {
65345       {
65346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65347       };
65348     }
65349   }
65350   jresult = result;
65351   return jresult;
65352 }
65353
65354
65355 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
65356   float jresult ;
65357   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65358   float result;
65359
65360   arg1 = (Dali::Toolkit::Button *)jarg1;
65361   {
65362     try {
65363       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
65364     } catch (std::out_of_range& e) {
65365       {
65366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65367       };
65368     } catch (std::exception& e) {
65369       {
65370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65371       };
65372     } catch (...) {
65373       {
65374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65375       };
65376     }
65377   }
65378   jresult = result;
65379   return jresult;
65380 }
65381
65382
65383 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
65384   char * jresult ;
65385   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65386   std::string result;
65387
65388   arg1 = (Dali::Toolkit::Button *)jarg1;
65389   {
65390     try {
65391       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
65392     } catch (std::out_of_range& e) {
65393       {
65394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65395       };
65396     } catch (std::exception& e) {
65397       {
65398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65399       };
65400     } catch (...) {
65401       {
65402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65403       };
65404     }
65405   }
65406   jresult = SWIG_csharp_string_callback((&result)->c_str());
65407   return jresult;
65408 }
65409
65410
65411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
65412   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65413   Dali::Actor arg2 ;
65414   Dali::Actor *argp2 ;
65415
65416   arg1 = (Dali::Toolkit::Button *)jarg1;
65417   argp2 = (Dali::Actor *)jarg2;
65418   if (!argp2) {
65419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65420     return ;
65421   }
65422   arg2 = *argp2;
65423   {
65424     try {
65425       (arg1)->SetLabel(arg2);
65426     } catch (std::out_of_range& e) {
65427       {
65428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65429       };
65430     } catch (std::exception& e) {
65431       {
65432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65433       };
65434     } catch (...) {
65435       {
65436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65437       };
65438     }
65439   }
65440 }
65441
65442
65443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
65444   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65445   Dali::Image arg2 ;
65446   Dali::Image *argp2 ;
65447
65448   arg1 = (Dali::Toolkit::Button *)jarg1;
65449   argp2 = (Dali::Image *)jarg2;
65450   if (!argp2) {
65451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65452     return ;
65453   }
65454   arg2 = *argp2;
65455   {
65456     try {
65457       (arg1)->SetButtonImage(arg2);
65458     } catch (std::out_of_range& e) {
65459       {
65460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65461       };
65462     } catch (std::exception& e) {
65463       {
65464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65465       };
65466     } catch (...) {
65467       {
65468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65469       };
65470     }
65471   }
65472 }
65473
65474
65475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
65476   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65477   Dali::Image arg2 ;
65478   Dali::Image *argp2 ;
65479
65480   arg1 = (Dali::Toolkit::Button *)jarg1;
65481   argp2 = (Dali::Image *)jarg2;
65482   if (!argp2) {
65483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65484     return ;
65485   }
65486   arg2 = *argp2;
65487   {
65488     try {
65489       (arg1)->SetSelectedImage(arg2);
65490     } catch (std::out_of_range& e) {
65491       {
65492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65493       };
65494     } catch (std::exception& e) {
65495       {
65496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65497       };
65498     } catch (...) {
65499       {
65500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65501       };
65502     }
65503   }
65504 }
65505
65506
65507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
65508   void * jresult ;
65509   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65510   Dali::Actor result;
65511
65512   arg1 = (Dali::Toolkit::Button *)jarg1;
65513   {
65514     try {
65515       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
65516     } catch (std::out_of_range& e) {
65517       {
65518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65519       };
65520     } catch (std::exception& e) {
65521       {
65522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65523       };
65524     } catch (...) {
65525       {
65526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65527       };
65528     }
65529   }
65530   jresult = new Dali::Actor((const Dali::Actor &)result);
65531   return jresult;
65532 }
65533
65534
65535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
65536   void * jresult ;
65537   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65538   Dali::Actor result;
65539
65540   arg1 = (Dali::Toolkit::Button *)jarg1;
65541   {
65542     try {
65543       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
65544     } catch (std::out_of_range& e) {
65545       {
65546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65547       };
65548     } catch (std::exception& e) {
65549       {
65550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65551       };
65552     } catch (...) {
65553       {
65554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65555       };
65556     }
65557   }
65558   jresult = new Dali::Actor((const Dali::Actor &)result);
65559   return jresult;
65560 }
65561
65562
65563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
65564   void * jresult ;
65565   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65566   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65567
65568   arg1 = (Dali::Toolkit::Button *)jarg1;
65569   {
65570     try {
65571       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
65572     } catch (std::out_of_range& e) {
65573       {
65574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65575       };
65576     } catch (std::exception& e) {
65577       {
65578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65579       };
65580     } catch (...) {
65581       {
65582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65583       };
65584     }
65585   }
65586   jresult = (void *)result;
65587   return jresult;
65588 }
65589
65590
65591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
65592   void * jresult ;
65593   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65594   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65595
65596   arg1 = (Dali::Toolkit::Button *)jarg1;
65597   {
65598     try {
65599       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
65600     } catch (std::out_of_range& e) {
65601       {
65602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65603       };
65604     } catch (std::exception& e) {
65605       {
65606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65607       };
65608     } catch (...) {
65609       {
65610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65611       };
65612     }
65613   }
65614   jresult = (void *)result;
65615   return jresult;
65616 }
65617
65618
65619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
65620   void * jresult ;
65621   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65622   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65623
65624   arg1 = (Dali::Toolkit::Button *)jarg1;
65625   {
65626     try {
65627       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
65628     } catch (std::out_of_range& e) {
65629       {
65630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65631       };
65632     } catch (std::exception& e) {
65633       {
65634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65635       };
65636     } catch (...) {
65637       {
65638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65639       };
65640     }
65641   }
65642   jresult = (void *)result;
65643   return jresult;
65644 }
65645
65646
65647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
65648   void * jresult ;
65649   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65650   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65651
65652   arg1 = (Dali::Toolkit::Button *)jarg1;
65653   {
65654     try {
65655       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
65656     } catch (std::out_of_range& e) {
65657       {
65658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65659       };
65660     } catch (std::exception& e) {
65661       {
65662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65663       };
65664     } catch (...) {
65665       {
65666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65667       };
65668     }
65669   }
65670   jresult = (void *)result;
65671   return jresult;
65672 }
65673
65674
65675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
65676   void * jresult ;
65677   Dali::Toolkit::CheckBoxButton *result = 0 ;
65678
65679   {
65680     try {
65681       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
65682     } catch (std::out_of_range& e) {
65683       {
65684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65685       };
65686     } catch (std::exception& e) {
65687       {
65688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65689       };
65690     } catch (...) {
65691       {
65692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65693       };
65694     }
65695   }
65696   jresult = (void *)result;
65697   return jresult;
65698 }
65699
65700
65701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
65702   void * jresult ;
65703   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
65704   Dali::Toolkit::CheckBoxButton *result = 0 ;
65705
65706   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65707   if (!arg1) {
65708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65709     return 0;
65710   }
65711   {
65712     try {
65713       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
65714     } catch (std::out_of_range& e) {
65715       {
65716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65717       };
65718     } catch (std::exception& e) {
65719       {
65720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65721       };
65722     } catch (...) {
65723       {
65724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65725       };
65726     }
65727   }
65728   jresult = (void *)result;
65729   return jresult;
65730 }
65731
65732
65733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
65734   void * jresult ;
65735   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65736   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
65737   Dali::Toolkit::CheckBoxButton *result = 0 ;
65738
65739   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65740   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
65741   if (!arg2) {
65742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65743     return 0;
65744   }
65745   {
65746     try {
65747       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
65748     } catch (std::out_of_range& e) {
65749       {
65750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65751       };
65752     } catch (std::exception& e) {
65753       {
65754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65755       };
65756     } catch (...) {
65757       {
65758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65759       };
65760     }
65761   }
65762   jresult = (void *)result;
65763   return jresult;
65764 }
65765
65766
65767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
65768   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65769
65770   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65771   {
65772     try {
65773       delete arg1;
65774     } catch (std::out_of_range& e) {
65775       {
65776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65777       };
65778     } catch (std::exception& e) {
65779       {
65780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65781       };
65782     } catch (...) {
65783       {
65784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65785       };
65786     }
65787   }
65788 }
65789
65790
65791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
65792   void * jresult ;
65793   Dali::Toolkit::CheckBoxButton result;
65794
65795   {
65796     try {
65797       result = Dali::Toolkit::CheckBoxButton::New();
65798     } catch (std::out_of_range& e) {
65799       {
65800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65801       };
65802     } catch (std::exception& e) {
65803       {
65804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65805       };
65806     } catch (...) {
65807       {
65808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65809       };
65810     }
65811   }
65812   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65813   return jresult;
65814 }
65815
65816
65817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
65818   void * jresult ;
65819   Dali::BaseHandle arg1 ;
65820   Dali::BaseHandle *argp1 ;
65821   Dali::Toolkit::CheckBoxButton result;
65822
65823   argp1 = (Dali::BaseHandle *)jarg1;
65824   if (!argp1) {
65825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65826     return 0;
65827   }
65828   arg1 = *argp1;
65829   {
65830     try {
65831       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
65832     } catch (std::out_of_range& e) {
65833       {
65834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65835       };
65836     } catch (std::exception& e) {
65837       {
65838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65839       };
65840     } catch (...) {
65841       {
65842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65843       };
65844     }
65845   }
65846   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65847   return jresult;
65848 }
65849
65850
65851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
65852   int jresult ;
65853   int result;
65854
65855   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
65856   jresult = (int)result;
65857   return jresult;
65858 }
65859
65860
65861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
65862   int jresult ;
65863   int result;
65864
65865   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
65866   jresult = (int)result;
65867   return jresult;
65868 }
65869
65870
65871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
65872   int jresult ;
65873   int result;
65874
65875   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
65876   jresult = (int)result;
65877   return jresult;
65878 }
65879
65880
65881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
65882   int jresult ;
65883   int result;
65884
65885   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
65886   jresult = (int)result;
65887   return jresult;
65888 }
65889
65890
65891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
65892   int jresult ;
65893   int result;
65894
65895   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
65896   jresult = (int)result;
65897   return jresult;
65898 }
65899
65900
65901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
65902   void * jresult ;
65903   Dali::Toolkit::PushButton::Property *result = 0 ;
65904
65905   {
65906     try {
65907       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
65908     } catch (std::out_of_range& e) {
65909       {
65910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65911       };
65912     } catch (std::exception& e) {
65913       {
65914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65915       };
65916     } catch (...) {
65917       {
65918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65919       };
65920     }
65921   }
65922   jresult = (void *)result;
65923   return jresult;
65924 }
65925
65926
65927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
65928   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
65929
65930   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
65931   {
65932     try {
65933       delete arg1;
65934     } catch (std::out_of_range& e) {
65935       {
65936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65937       };
65938     } catch (std::exception& e) {
65939       {
65940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65941       };
65942     } catch (...) {
65943       {
65944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65945       };
65946     }
65947   }
65948 }
65949
65950
65951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
65952   void * jresult ;
65953   Dali::Toolkit::PushButton *result = 0 ;
65954
65955   {
65956     try {
65957       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
65958     } catch (std::out_of_range& e) {
65959       {
65960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65961       };
65962     } catch (std::exception& e) {
65963       {
65964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65965       };
65966     } catch (...) {
65967       {
65968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65969       };
65970     }
65971   }
65972   jresult = (void *)result;
65973   return jresult;
65974 }
65975
65976
65977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
65978   void * jresult ;
65979   Dali::Toolkit::PushButton *arg1 = 0 ;
65980   Dali::Toolkit::PushButton *result = 0 ;
65981
65982   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65983   if (!arg1) {
65984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
65985     return 0;
65986   }
65987   {
65988     try {
65989       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
65990     } catch (std::out_of_range& e) {
65991       {
65992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65993       };
65994     } catch (std::exception& e) {
65995       {
65996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65997       };
65998     } catch (...) {
65999       {
66000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66001       };
66002     }
66003   }
66004   jresult = (void *)result;
66005   return jresult;
66006 }
66007
66008
66009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
66010   void * jresult ;
66011   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66012   Dali::Toolkit::PushButton *arg2 = 0 ;
66013   Dali::Toolkit::PushButton *result = 0 ;
66014
66015   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66016   arg2 = (Dali::Toolkit::PushButton *)jarg2;
66017   if (!arg2) {
66018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
66019     return 0;
66020   }
66021   {
66022     try {
66023       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
66024     } catch (std::out_of_range& e) {
66025       {
66026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66027       };
66028     } catch (std::exception& e) {
66029       {
66030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66031       };
66032     } catch (...) {
66033       {
66034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66035       };
66036     }
66037   }
66038   jresult = (void *)result;
66039   return jresult;
66040 }
66041
66042
66043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
66044   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66045
66046   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66047   {
66048     try {
66049       delete arg1;
66050     } catch (std::out_of_range& e) {
66051       {
66052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66053       };
66054     } catch (std::exception& e) {
66055       {
66056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66057       };
66058     } catch (...) {
66059       {
66060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66061       };
66062     }
66063   }
66064 }
66065
66066
66067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
66068   void * jresult ;
66069   Dali::Toolkit::PushButton result;
66070
66071   {
66072     try {
66073       result = Dali::Toolkit::PushButton::New();
66074     } catch (std::out_of_range& e) {
66075       {
66076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66077       };
66078     } catch (std::exception& e) {
66079       {
66080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66081       };
66082     } catch (...) {
66083       {
66084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66085       };
66086     }
66087   }
66088   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
66089   return jresult;
66090 }
66091
66092
66093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
66094   void * jresult ;
66095   Dali::BaseHandle arg1 ;
66096   Dali::BaseHandle *argp1 ;
66097   Dali::Toolkit::PushButton result;
66098
66099   argp1 = (Dali::BaseHandle *)jarg1;
66100   if (!argp1) {
66101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66102     return 0;
66103   }
66104   arg1 = *argp1;
66105   {
66106     try {
66107       result = Dali::Toolkit::PushButton::DownCast(arg1);
66108     } catch (std::out_of_range& e) {
66109       {
66110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66111       };
66112     } catch (std::exception& e) {
66113       {
66114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66115       };
66116     } catch (...) {
66117       {
66118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66119       };
66120     }
66121   }
66122   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
66123   return jresult;
66124 }
66125
66126
66127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
66128   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66129   Dali::Image arg2 ;
66130   Dali::Image *argp2 ;
66131
66132   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66133   argp2 = (Dali::Image *)jarg2;
66134   if (!argp2) {
66135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
66136     return ;
66137   }
66138   arg2 = *argp2;
66139   {
66140     try {
66141       (arg1)->SetButtonImage(arg2);
66142     } catch (std::out_of_range& e) {
66143       {
66144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66145       };
66146     } catch (std::exception& e) {
66147       {
66148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66149       };
66150     } catch (...) {
66151       {
66152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66153       };
66154     }
66155   }
66156 }
66157
66158
66159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
66160   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66161   Dali::Actor arg2 ;
66162   Dali::Actor *argp2 ;
66163
66164   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66165   argp2 = (Dali::Actor *)jarg2;
66166   if (!argp2) {
66167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66168     return ;
66169   }
66170   arg2 = *argp2;
66171   {
66172     try {
66173       (arg1)->SetButtonImage(arg2);
66174     } catch (std::out_of_range& e) {
66175       {
66176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66177       };
66178     } catch (std::exception& e) {
66179       {
66180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66181       };
66182     } catch (...) {
66183       {
66184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66185       };
66186     }
66187   }
66188 }
66189
66190
66191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
66192   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66193   Dali::Actor arg2 ;
66194   Dali::Actor *argp2 ;
66195
66196   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66197   argp2 = (Dali::Actor *)jarg2;
66198   if (!argp2) {
66199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66200     return ;
66201   }
66202   arg2 = *argp2;
66203   {
66204     try {
66205       (arg1)->SetBackgroundImage(arg2);
66206     } catch (std::out_of_range& e) {
66207       {
66208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66209       };
66210     } catch (std::exception& e) {
66211       {
66212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66213       };
66214     } catch (...) {
66215       {
66216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66217       };
66218     }
66219   }
66220 }
66221
66222
66223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
66224   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66225   Dali::Image arg2 ;
66226   Dali::Image *argp2 ;
66227
66228   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66229   argp2 = (Dali::Image *)jarg2;
66230   if (!argp2) {
66231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
66232     return ;
66233   }
66234   arg2 = *argp2;
66235   {
66236     try {
66237       (arg1)->SetSelectedImage(arg2);
66238     } catch (std::out_of_range& e) {
66239       {
66240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66241       };
66242     } catch (std::exception& e) {
66243       {
66244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66245       };
66246     } catch (...) {
66247       {
66248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66249       };
66250     }
66251   }
66252 }
66253
66254
66255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
66256   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66257   Dali::Actor arg2 ;
66258   Dali::Actor *argp2 ;
66259
66260   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66261   argp2 = (Dali::Actor *)jarg2;
66262   if (!argp2) {
66263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66264     return ;
66265   }
66266   arg2 = *argp2;
66267   {
66268     try {
66269       (arg1)->SetSelectedImage(arg2);
66270     } catch (std::out_of_range& e) {
66271       {
66272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66273       };
66274     } catch (std::exception& e) {
66275       {
66276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66277       };
66278     } catch (...) {
66279       {
66280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66281       };
66282     }
66283   }
66284 }
66285
66286
66287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
66288   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66289   Dali::Actor arg2 ;
66290   Dali::Actor *argp2 ;
66291
66292   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66293   argp2 = (Dali::Actor *)jarg2;
66294   if (!argp2) {
66295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66296     return ;
66297   }
66298   arg2 = *argp2;
66299   {
66300     try {
66301       (arg1)->SetSelectedBackgroundImage(arg2);
66302     } catch (std::out_of_range& e) {
66303       {
66304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66305       };
66306     } catch (std::exception& e) {
66307       {
66308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66309       };
66310     } catch (...) {
66311       {
66312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66313       };
66314     }
66315   }
66316 }
66317
66318
66319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
66320   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66321   Dali::Actor arg2 ;
66322   Dali::Actor *argp2 ;
66323
66324   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66325   argp2 = (Dali::Actor *)jarg2;
66326   if (!argp2) {
66327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66328     return ;
66329   }
66330   arg2 = *argp2;
66331   {
66332     try {
66333       (arg1)->SetDisabledBackgroundImage(arg2);
66334     } catch (std::out_of_range& e) {
66335       {
66336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66337       };
66338     } catch (std::exception& e) {
66339       {
66340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66341       };
66342     } catch (...) {
66343       {
66344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66345       };
66346     }
66347   }
66348 }
66349
66350
66351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
66352   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66353   Dali::Actor arg2 ;
66354   Dali::Actor *argp2 ;
66355
66356   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66357   argp2 = (Dali::Actor *)jarg2;
66358   if (!argp2) {
66359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66360     return ;
66361   }
66362   arg2 = *argp2;
66363   {
66364     try {
66365       (arg1)->SetDisabledImage(arg2);
66366     } catch (std::out_of_range& e) {
66367       {
66368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66369       };
66370     } catch (std::exception& e) {
66371       {
66372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66373       };
66374     } catch (...) {
66375       {
66376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66377       };
66378     }
66379   }
66380 }
66381
66382
66383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
66384   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66385   Dali::Actor arg2 ;
66386   Dali::Actor *argp2 ;
66387
66388   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66389   argp2 = (Dali::Actor *)jarg2;
66390   if (!argp2) {
66391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66392     return ;
66393   }
66394   arg2 = *argp2;
66395   {
66396     try {
66397       (arg1)->SetDisabledSelectedImage(arg2);
66398     } catch (std::out_of_range& e) {
66399       {
66400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66401       };
66402     } catch (std::exception& e) {
66403       {
66404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66405       };
66406     } catch (...) {
66407       {
66408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66409       };
66410     }
66411   }
66412 }
66413
66414
66415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
66416   void * jresult ;
66417   Dali::Toolkit::RadioButton *result = 0 ;
66418
66419   {
66420     try {
66421       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
66422     } catch (std::out_of_range& e) {
66423       {
66424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66425       };
66426     } catch (std::exception& e) {
66427       {
66428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66429       };
66430     } catch (...) {
66431       {
66432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66433       };
66434     }
66435   }
66436   jresult = (void *)result;
66437   return jresult;
66438 }
66439
66440
66441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
66442   void * jresult ;
66443   Dali::Toolkit::RadioButton *arg1 = 0 ;
66444   Dali::Toolkit::RadioButton *result = 0 ;
66445
66446   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66447   if (!arg1) {
66448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
66449     return 0;
66450   }
66451   {
66452     try {
66453       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
66454     } catch (std::out_of_range& e) {
66455       {
66456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66457       };
66458     } catch (std::exception& e) {
66459       {
66460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66461       };
66462     } catch (...) {
66463       {
66464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66465       };
66466     }
66467   }
66468   jresult = (void *)result;
66469   return jresult;
66470 }
66471
66472
66473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
66474   void * jresult ;
66475   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
66476   Dali::Toolkit::RadioButton *arg2 = 0 ;
66477   Dali::Toolkit::RadioButton *result = 0 ;
66478
66479   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66480   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
66481   if (!arg2) {
66482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
66483     return 0;
66484   }
66485   {
66486     try {
66487       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
66488     } catch (std::out_of_range& e) {
66489       {
66490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66491       };
66492     } catch (std::exception& e) {
66493       {
66494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66495       };
66496     } catch (...) {
66497       {
66498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66499       };
66500     }
66501   }
66502   jresult = (void *)result;
66503   return jresult;
66504 }
66505
66506
66507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
66508   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
66509
66510   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66511   {
66512     try {
66513       delete arg1;
66514     } catch (std::out_of_range& e) {
66515       {
66516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66517       };
66518     } catch (std::exception& e) {
66519       {
66520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66521       };
66522     } catch (...) {
66523       {
66524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66525       };
66526     }
66527   }
66528 }
66529
66530
66531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
66532   void * jresult ;
66533   Dali::Toolkit::RadioButton result;
66534
66535   {
66536     try {
66537       result = Dali::Toolkit::RadioButton::New();
66538     } catch (std::out_of_range& e) {
66539       {
66540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66541       };
66542     } catch (std::exception& e) {
66543       {
66544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66545       };
66546     } catch (...) {
66547       {
66548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66549       };
66550     }
66551   }
66552   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66553   return jresult;
66554 }
66555
66556
66557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
66558   void * jresult ;
66559   std::string *arg1 = 0 ;
66560   Dali::Toolkit::RadioButton result;
66561
66562   if (!jarg1) {
66563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66564     return 0;
66565   }
66566   std::string arg1_str(jarg1);
66567   arg1 = &arg1_str;
66568   {
66569     try {
66570       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
66571     } catch (std::out_of_range& e) {
66572       {
66573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66574       };
66575     } catch (std::exception& e) {
66576       {
66577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66578       };
66579     } catch (...) {
66580       {
66581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66582       };
66583     }
66584   }
66585   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66586
66587   //argout typemap for const std::string&
66588
66589   return jresult;
66590 }
66591
66592
66593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
66594   void * jresult ;
66595   Dali::BaseHandle arg1 ;
66596   Dali::BaseHandle *argp1 ;
66597   Dali::Toolkit::RadioButton result;
66598
66599   argp1 = (Dali::BaseHandle *)jarg1;
66600   if (!argp1) {
66601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66602     return 0;
66603   }
66604   arg1 = *argp1;
66605   {
66606     try {
66607       result = Dali::Toolkit::RadioButton::DownCast(arg1);
66608     } catch (std::out_of_range& e) {
66609       {
66610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66611       };
66612     } catch (std::exception& e) {
66613       {
66614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66615       };
66616     } catch (...) {
66617       {
66618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66619       };
66620     }
66621   }
66622   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66623   return jresult;
66624 }
66625
66626
66627 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
66628   int jresult ;
66629   int result;
66630
66631   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
66632   jresult = (int)result;
66633   return jresult;
66634 }
66635
66636
66637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
66638   int jresult ;
66639   int result;
66640
66641   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
66642   jresult = (int)result;
66643   return jresult;
66644 }
66645
66646
66647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
66648   int jresult ;
66649   int result;
66650
66651   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
66652   jresult = (int)result;
66653   return jresult;
66654 }
66655
66656
66657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
66658   int jresult ;
66659   int result;
66660
66661   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
66662   jresult = (int)result;
66663   return jresult;
66664 }
66665
66666
66667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
66668   int jresult ;
66669   int result;
66670
66671   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
66672   jresult = (int)result;
66673   return jresult;
66674 }
66675
66676
66677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
66678   int jresult ;
66679   int result;
66680
66681   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
66682   jresult = (int)result;
66683   return jresult;
66684 }
66685
66686
66687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
66688   void * jresult ;
66689   Dali::Toolkit::FlexContainer::Property *result = 0 ;
66690
66691   {
66692     try {
66693       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
66694     } catch (std::out_of_range& e) {
66695       {
66696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66697       };
66698     } catch (std::exception& e) {
66699       {
66700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66701       };
66702     } catch (...) {
66703       {
66704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66705       };
66706     }
66707   }
66708   jresult = (void *)result;
66709   return jresult;
66710 }
66711
66712
66713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
66714   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
66715
66716   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
66717   {
66718     try {
66719       delete arg1;
66720     } catch (std::out_of_range& e) {
66721       {
66722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66723       };
66724     } catch (std::exception& e) {
66725       {
66726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66727       };
66728     } catch (...) {
66729       {
66730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66731       };
66732     }
66733   }
66734 }
66735
66736
66737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
66738   int jresult ;
66739   int result;
66740
66741   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
66742   jresult = (int)result;
66743   return jresult;
66744 }
66745
66746
66747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
66748   int jresult ;
66749   int result;
66750
66751   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
66752   jresult = (int)result;
66753   return jresult;
66754 }
66755
66756
66757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
66758   int jresult ;
66759   int result;
66760
66761   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
66762   jresult = (int)result;
66763   return jresult;
66764 }
66765
66766
66767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
66768   void * jresult ;
66769   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
66770
66771   {
66772     try {
66773       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
66774     } catch (std::out_of_range& e) {
66775       {
66776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66777       };
66778     } catch (std::exception& e) {
66779       {
66780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66781       };
66782     } catch (...) {
66783       {
66784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66785       };
66786     }
66787   }
66788   jresult = (void *)result;
66789   return jresult;
66790 }
66791
66792
66793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
66794   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
66795
66796   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
66797   {
66798     try {
66799       delete arg1;
66800     } catch (std::out_of_range& e) {
66801       {
66802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66803       };
66804     } catch (std::exception& e) {
66805       {
66806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66807       };
66808     } catch (...) {
66809       {
66810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66811       };
66812     }
66813   }
66814 }
66815
66816
66817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
66818   void * jresult ;
66819   Dali::Toolkit::FlexContainer *result = 0 ;
66820
66821   {
66822     try {
66823       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
66824     } catch (std::out_of_range& e) {
66825       {
66826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66827       };
66828     } catch (std::exception& e) {
66829       {
66830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66831       };
66832     } catch (...) {
66833       {
66834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66835       };
66836     }
66837   }
66838   jresult = (void *)result;
66839   return jresult;
66840 }
66841
66842
66843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
66844   void * jresult ;
66845   Dali::Toolkit::FlexContainer *arg1 = 0 ;
66846   Dali::Toolkit::FlexContainer *result = 0 ;
66847
66848   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66849   if (!arg1) {
66850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66851     return 0;
66852   }
66853   {
66854     try {
66855       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
66856     } catch (std::out_of_range& e) {
66857       {
66858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66859       };
66860     } catch (std::exception& e) {
66861       {
66862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66863       };
66864     } catch (...) {
66865       {
66866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66867       };
66868     }
66869   }
66870   jresult = (void *)result;
66871   return jresult;
66872 }
66873
66874
66875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
66876   void * jresult ;
66877   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66878   Dali::Toolkit::FlexContainer *arg2 = 0 ;
66879   Dali::Toolkit::FlexContainer *result = 0 ;
66880
66881   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66882   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
66883   if (!arg2) {
66884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66885     return 0;
66886   }
66887   {
66888     try {
66889       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
66890     } catch (std::out_of_range& e) {
66891       {
66892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66893       };
66894     } catch (std::exception& e) {
66895       {
66896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66897       };
66898     } catch (...) {
66899       {
66900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66901       };
66902     }
66903   }
66904   jresult = (void *)result;
66905   return jresult;
66906 }
66907
66908
66909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
66910   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66911
66912   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66913   {
66914     try {
66915       delete arg1;
66916     } catch (std::out_of_range& e) {
66917       {
66918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66919       };
66920     } catch (std::exception& e) {
66921       {
66922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66923       };
66924     } catch (...) {
66925       {
66926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66927       };
66928     }
66929   }
66930 }
66931
66932
66933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
66934   void * jresult ;
66935   Dali::Toolkit::FlexContainer result;
66936
66937   {
66938     try {
66939       result = Dali::Toolkit::FlexContainer::New();
66940     } catch (std::out_of_range& e) {
66941       {
66942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66943       };
66944     } catch (std::exception& e) {
66945       {
66946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66947       };
66948     } catch (...) {
66949       {
66950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66951       };
66952     }
66953   }
66954   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66955   return jresult;
66956 }
66957
66958
66959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
66960   void * jresult ;
66961   Dali::BaseHandle arg1 ;
66962   Dali::BaseHandle *argp1 ;
66963   Dali::Toolkit::FlexContainer result;
66964
66965   argp1 = (Dali::BaseHandle *)jarg1;
66966   if (!argp1) {
66967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66968     return 0;
66969   }
66970   arg1 = *argp1;
66971   {
66972     try {
66973       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
66974     } catch (std::out_of_range& e) {
66975       {
66976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66977       };
66978     } catch (std::exception& e) {
66979       {
66980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66981       };
66982     } catch (...) {
66983       {
66984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66985       };
66986     }
66987   }
66988   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66989   return jresult;
66990 }
66991
66992
66993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
66994   int jresult ;
66995   int result;
66996
66997   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
66998   jresult = (int)result;
66999   return jresult;
67000 }
67001
67002
67003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
67004   int jresult ;
67005   int result;
67006
67007   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
67008   jresult = (int)result;
67009   return jresult;
67010 }
67011
67012
67013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
67014   int jresult ;
67015   int result;
67016
67017   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
67018   jresult = (int)result;
67019   return jresult;
67020 }
67021
67022
67023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
67024   int jresult ;
67025   int result;
67026
67027   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
67028   jresult = (int)result;
67029   return jresult;
67030 }
67031
67032
67033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
67034   void * jresult ;
67035   Dali::Toolkit::ImageView::Property *result = 0 ;
67036
67037   {
67038     try {
67039       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
67040     } catch (std::out_of_range& e) {
67041       {
67042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67043       };
67044     } catch (std::exception& e) {
67045       {
67046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67047       };
67048     } catch (...) {
67049       {
67050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67051       };
67052     }
67053   }
67054   jresult = (void *)result;
67055   return jresult;
67056 }
67057
67058
67059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
67060   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
67061
67062   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
67063   {
67064     try {
67065       delete arg1;
67066     } catch (std::out_of_range& e) {
67067       {
67068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67069       };
67070     } catch (std::exception& e) {
67071       {
67072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67073       };
67074     } catch (...) {
67075       {
67076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67077       };
67078     }
67079   }
67080 }
67081
67082
67083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
67084   void * jresult ;
67085   Dali::Toolkit::ImageView *result = 0 ;
67086
67087   {
67088     try {
67089       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
67090     } catch (std::out_of_range& e) {
67091       {
67092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67093       };
67094     } catch (std::exception& e) {
67095       {
67096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67097       };
67098     } catch (...) {
67099       {
67100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67101       };
67102     }
67103   }
67104   jresult = (void *)result;
67105   return jresult;
67106 }
67107
67108
67109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
67110   void * jresult ;
67111   Dali::Toolkit::ImageView result;
67112
67113   {
67114     try {
67115       result = Dali::Toolkit::ImageView::New();
67116     } catch (std::out_of_range& e) {
67117       {
67118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67119       };
67120     } catch (std::exception& e) {
67121       {
67122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67123       };
67124     } catch (...) {
67125       {
67126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67127       };
67128     }
67129   }
67130   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67131   return jresult;
67132 }
67133
67134
67135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
67136   void * jresult ;
67137   Dali::Image arg1 ;
67138   Dali::Image *argp1 ;
67139   Dali::Toolkit::ImageView result;
67140
67141   argp1 = (Dali::Image *)jarg1;
67142   if (!argp1) {
67143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
67144     return 0;
67145   }
67146   arg1 = *argp1;
67147   {
67148     try {
67149       result = Dali::Toolkit::ImageView::New(arg1);
67150     } catch (std::out_of_range& e) {
67151       {
67152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67153       };
67154     } catch (std::exception& e) {
67155       {
67156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67157       };
67158     } catch (...) {
67159       {
67160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67161       };
67162     }
67163   }
67164   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67165   return jresult;
67166 }
67167
67168
67169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
67170   void * jresult ;
67171   std::string *arg1 = 0 ;
67172   Dali::Toolkit::ImageView result;
67173
67174   if (!jarg1) {
67175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67176     return 0;
67177   }
67178   std::string arg1_str(jarg1);
67179   arg1 = &arg1_str;
67180   {
67181     try {
67182       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
67183     } catch (std::out_of_range& e) {
67184       {
67185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67186       };
67187     } catch (std::exception& e) {
67188       {
67189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67190       };
67191     } catch (...) {
67192       {
67193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67194       };
67195     }
67196   }
67197   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67198
67199   //argout typemap for const std::string&
67200
67201   return jresult;
67202 }
67203
67204
67205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
67206   void * jresult ;
67207   std::string *arg1 = 0 ;
67208   Dali::ImageDimensions arg2 ;
67209   Dali::ImageDimensions *argp2 ;
67210   Dali::Toolkit::ImageView result;
67211
67212   if (!jarg1) {
67213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67214     return 0;
67215   }
67216   std::string arg1_str(jarg1);
67217   arg1 = &arg1_str;
67218   argp2 = (Dali::ImageDimensions *)jarg2;
67219   if (!argp2) {
67220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
67221     return 0;
67222   }
67223   arg2 = *argp2;
67224   {
67225     try {
67226       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
67227     } catch (std::out_of_range& e) {
67228       {
67229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67230       };
67231     } catch (std::exception& e) {
67232       {
67233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67234       };
67235     } catch (...) {
67236       {
67237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67238       };
67239     }
67240   }
67241   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67242
67243   //argout typemap for const std::string&
67244
67245   return jresult;
67246 }
67247
67248
67249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
67250   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67251
67252   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67253   {
67254     try {
67255       delete arg1;
67256     } catch (std::out_of_range& e) {
67257       {
67258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67259       };
67260     } catch (std::exception& e) {
67261       {
67262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67263       };
67264     } catch (...) {
67265       {
67266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67267       };
67268     }
67269   }
67270 }
67271
67272
67273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
67274   void * jresult ;
67275   Dali::Toolkit::ImageView *arg1 = 0 ;
67276   Dali::Toolkit::ImageView *result = 0 ;
67277
67278   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67279   if (!arg1) {
67280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
67281     return 0;
67282   }
67283   {
67284     try {
67285       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
67286     } catch (std::out_of_range& e) {
67287       {
67288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67289       };
67290     } catch (std::exception& e) {
67291       {
67292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67293       };
67294     } catch (...) {
67295       {
67296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67297       };
67298     }
67299   }
67300   jresult = (void *)result;
67301   return jresult;
67302 }
67303
67304
67305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
67306   void * jresult ;
67307   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67308   Dali::Toolkit::ImageView *arg2 = 0 ;
67309   Dali::Toolkit::ImageView *result = 0 ;
67310
67311   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67312   arg2 = (Dali::Toolkit::ImageView *)jarg2;
67313   if (!arg2) {
67314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
67315     return 0;
67316   }
67317   {
67318     try {
67319       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
67320     } catch (std::out_of_range& e) {
67321       {
67322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67323       };
67324     } catch (std::exception& e) {
67325       {
67326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67327       };
67328     } catch (...) {
67329       {
67330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67331       };
67332     }
67333   }
67334   jresult = (void *)result;
67335   return jresult;
67336 }
67337
67338
67339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
67340   void * jresult ;
67341   Dali::BaseHandle arg1 ;
67342   Dali::BaseHandle *argp1 ;
67343   Dali::Toolkit::ImageView result;
67344
67345   argp1 = (Dali::BaseHandle *)jarg1;
67346   if (!argp1) {
67347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67348     return 0;
67349   }
67350   arg1 = *argp1;
67351   {
67352     try {
67353       result = Dali::Toolkit::ImageView::DownCast(arg1);
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 = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67369   return jresult;
67370 }
67371
67372
67373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
67374   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67375   Dali::Image arg2 ;
67376   Dali::Image *argp2 ;
67377
67378   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67379   argp2 = (Dali::Image *)jarg2;
67380   if (!argp2) {
67381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
67382     return ;
67383   }
67384   arg2 = *argp2;
67385   {
67386     try {
67387       (arg1)->SetImage(arg2);
67388     } catch (std::out_of_range& e) {
67389       {
67390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67391       };
67392     } catch (std::exception& e) {
67393       {
67394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67395       };
67396     } catch (...) {
67397       {
67398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67399       };
67400     }
67401   }
67402 }
67403
67404
67405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
67406   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67407   std::string *arg2 = 0 ;
67408
67409   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67410   if (!jarg2) {
67411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67412     return ;
67413   }
67414   std::string arg2_str(jarg2);
67415   arg2 = &arg2_str;
67416   {
67417     try {
67418       (arg1)->SetImage((std::string const &)*arg2);
67419     } catch (std::out_of_range& e) {
67420       {
67421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67422       };
67423     } catch (std::exception& e) {
67424       {
67425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67426       };
67427     } catch (...) {
67428       {
67429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67430       };
67431     }
67432   }
67433
67434   //argout typemap for const std::string&
67435
67436 }
67437
67438
67439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
67440   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67441   std::string *arg2 = 0 ;
67442   Dali::ImageDimensions arg3 ;
67443   Dali::ImageDimensions *argp3 ;
67444
67445   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67446   if (!jarg2) {
67447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67448     return ;
67449   }
67450   std::string arg2_str(jarg2);
67451   arg2 = &arg2_str;
67452   argp3 = (Dali::ImageDimensions *)jarg3;
67453   if (!argp3) {
67454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
67455     return ;
67456   }
67457   arg3 = *argp3;
67458   {
67459     try {
67460       (arg1)->SetImage((std::string const &)*arg2,arg3);
67461     } catch (std::out_of_range& e) {
67462       {
67463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67464       };
67465     } catch (std::exception& e) {
67466       {
67467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67468       };
67469     } catch (...) {
67470       {
67471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67472       };
67473     }
67474   }
67475
67476   //argout typemap for const std::string&
67477
67478 }
67479
67480
67481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
67482   void * jresult ;
67483   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67484   Dali::Image result;
67485
67486   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67487   {
67488     try {
67489       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
67490     } catch (std::out_of_range& e) {
67491       {
67492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67493       };
67494     } catch (std::exception& e) {
67495       {
67496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67497       };
67498     } catch (...) {
67499       {
67500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67501       };
67502     }
67503   }
67504   jresult = new Dali::Image((const Dali::Image &)result);
67505   return jresult;
67506 }
67507
67508
67509 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
67510   int jresult ;
67511   int result;
67512
67513   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
67514   jresult = (int)result;
67515   return jresult;
67516 }
67517
67518
67519 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
67520   int jresult ;
67521   int result;
67522
67523   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
67524   jresult = (int)result;
67525   return jresult;
67526 }
67527
67528
67529 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
67530   int jresult ;
67531   int result;
67532
67533   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
67534   jresult = (int)result;
67535   return jresult;
67536 }
67537
67538
67539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
67540   int jresult ;
67541   int result;
67542
67543   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
67544   jresult = (int)result;
67545   return jresult;
67546 }
67547
67548
67549 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
67550   int jresult ;
67551   int result;
67552
67553   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
67554   jresult = (int)result;
67555   return jresult;
67556 }
67557
67558
67559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
67560   int jresult ;
67561   int result;
67562
67563   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
67564   jresult = (int)result;
67565   return jresult;
67566 }
67567
67568
67569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
67570   int jresult ;
67571   int result;
67572
67573   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
67574   jresult = (int)result;
67575   return jresult;
67576 }
67577
67578
67579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
67580   int jresult ;
67581   int result;
67582
67583   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
67584   jresult = (int)result;
67585   return jresult;
67586 }
67587
67588
67589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
67590   void * jresult ;
67591   Dali::Toolkit::Model3dView::Property *result = 0 ;
67592
67593   {
67594     try {
67595       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
67596     } catch (std::out_of_range& e) {
67597       {
67598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67599       };
67600     } catch (std::exception& e) {
67601       {
67602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67603       };
67604     } catch (...) {
67605       {
67606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67607       };
67608     }
67609   }
67610   jresult = (void *)result;
67611   return jresult;
67612 }
67613
67614
67615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
67616   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
67617
67618   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
67619   {
67620     try {
67621       delete arg1;
67622     } catch (std::out_of_range& e) {
67623       {
67624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67625       };
67626     } catch (std::exception& e) {
67627       {
67628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67629       };
67630     } catch (...) {
67631       {
67632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67633       };
67634     }
67635   }
67636 }
67637
67638
67639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
67640   void * jresult ;
67641   Dali::Toolkit::Model3dView result;
67642
67643   {
67644     try {
67645       result = Dali::Toolkit::Model3dView::New();
67646     } catch (std::out_of_range& e) {
67647       {
67648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67649       };
67650     } catch (std::exception& e) {
67651       {
67652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67653       };
67654     } catch (...) {
67655       {
67656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67657       };
67658     }
67659   }
67660   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67661   return jresult;
67662 }
67663
67664
67665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
67666   void * jresult ;
67667   std::string *arg1 = 0 ;
67668   std::string *arg2 = 0 ;
67669   std::string *arg3 = 0 ;
67670   Dali::Toolkit::Model3dView result;
67671
67672   if (!jarg1) {
67673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67674     return 0;
67675   }
67676   std::string arg1_str(jarg1);
67677   arg1 = &arg1_str;
67678   if (!jarg2) {
67679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67680     return 0;
67681   }
67682   std::string arg2_str(jarg2);
67683   arg2 = &arg2_str;
67684   if (!jarg3) {
67685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67686     return 0;
67687   }
67688   std::string arg3_str(jarg3);
67689   arg3 = &arg3_str;
67690   {
67691     try {
67692       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
67693     } catch (std::out_of_range& e) {
67694       {
67695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67696       };
67697     } catch (std::exception& e) {
67698       {
67699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67700       };
67701     } catch (...) {
67702       {
67703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67704       };
67705     }
67706   }
67707   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67708
67709   //argout typemap for const std::string&
67710
67711
67712   //argout typemap for const std::string&
67713
67714
67715   //argout typemap for const std::string&
67716
67717   return jresult;
67718 }
67719
67720
67721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
67722   void * jresult ;
67723   Dali::Toolkit::Model3dView *result = 0 ;
67724
67725   {
67726     try {
67727       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
67728     } catch (std::out_of_range& e) {
67729       {
67730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67731       };
67732     } catch (std::exception& e) {
67733       {
67734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67735       };
67736     } catch (...) {
67737       {
67738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67739       };
67740     }
67741   }
67742   jresult = (void *)result;
67743   return jresult;
67744 }
67745
67746
67747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
67748   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67749
67750   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67751   {
67752     try {
67753       delete arg1;
67754     } catch (std::out_of_range& e) {
67755       {
67756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67757       };
67758     } catch (std::exception& e) {
67759       {
67760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67761       };
67762     } catch (...) {
67763       {
67764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67765       };
67766     }
67767   }
67768 }
67769
67770
67771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
67772   void * jresult ;
67773   Dali::Toolkit::Model3dView *arg1 = 0 ;
67774   Dali::Toolkit::Model3dView *result = 0 ;
67775
67776   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67777   if (!arg1) {
67778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67779     return 0;
67780   }
67781   {
67782     try {
67783       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
67784     } catch (std::out_of_range& e) {
67785       {
67786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67787       };
67788     } catch (std::exception& e) {
67789       {
67790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67791       };
67792     } catch (...) {
67793       {
67794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67795       };
67796     }
67797   }
67798   jresult = (void *)result;
67799   return jresult;
67800 }
67801
67802
67803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
67804   void * jresult ;
67805   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67806   Dali::Toolkit::Model3dView *arg2 = 0 ;
67807   Dali::Toolkit::Model3dView *result = 0 ;
67808
67809   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67810   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
67811   if (!arg2) {
67812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67813     return 0;
67814   }
67815   {
67816     try {
67817       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
67818     } catch (std::out_of_range& e) {
67819       {
67820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67821       };
67822     } catch (std::exception& e) {
67823       {
67824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67825       };
67826     } catch (...) {
67827       {
67828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67829       };
67830     }
67831   }
67832   jresult = (void *)result;
67833   return jresult;
67834 }
67835
67836
67837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
67838   void * jresult ;
67839   Dali::BaseHandle arg1 ;
67840   Dali::BaseHandle *argp1 ;
67841   Dali::Toolkit::Model3dView result;
67842
67843   argp1 = (Dali::BaseHandle *)jarg1;
67844   if (!argp1) {
67845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67846     return 0;
67847   }
67848   arg1 = *argp1;
67849   {
67850     try {
67851       result = Dali::Toolkit::Model3dView::DownCast(arg1);
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 = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67867   return jresult;
67868 }
67869
67870
67871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
67872   int jresult ;
67873   int result;
67874
67875   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
67876   jresult = (int)result;
67877   return jresult;
67878 }
67879
67880
67881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
67882   int jresult ;
67883   int result;
67884
67885   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
67886   jresult = (int)result;
67887   return jresult;
67888 }
67889
67890
67891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
67892   int jresult ;
67893   int result;
67894
67895   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
67896   jresult = (int)result;
67897   return jresult;
67898 }
67899
67900
67901 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
67902   int jresult ;
67903   int result;
67904
67905   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
67906   jresult = (int)result;
67907   return jresult;
67908 }
67909
67910
67911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
67912   int jresult ;
67913   int result;
67914
67915   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
67916   jresult = (int)result;
67917   return jresult;
67918 }
67919
67920
67921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
67922   int jresult ;
67923   int result;
67924
67925   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
67926   jresult = (int)result;
67927   return jresult;
67928 }
67929
67930
67931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
67932   int jresult ;
67933   int result;
67934
67935   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
67936   jresult = (int)result;
67937   return jresult;
67938 }
67939
67940
67941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
67942   int jresult ;
67943   int result;
67944
67945   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
67946   jresult = (int)result;
67947   return jresult;
67948 }
67949
67950
67951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
67952   int jresult ;
67953   int result;
67954
67955   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
67956   jresult = (int)result;
67957   return jresult;
67958 }
67959
67960
67961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
67962   void * jresult ;
67963   Dali::Toolkit::ScrollBar::Property *result = 0 ;
67964
67965   {
67966     try {
67967       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
67968     } catch (std::out_of_range& e) {
67969       {
67970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67971       };
67972     } catch (std::exception& e) {
67973       {
67974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67975       };
67976     } catch (...) {
67977       {
67978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67979       };
67980     }
67981   }
67982   jresult = (void *)result;
67983   return jresult;
67984 }
67985
67986
67987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
67988   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
67989
67990   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
67991   {
67992     try {
67993       delete arg1;
67994     } catch (std::out_of_range& e) {
67995       {
67996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67997       };
67998     } catch (std::exception& e) {
67999       {
68000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68001       };
68002     } catch (...) {
68003       {
68004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68005       };
68006     }
68007   }
68008 }
68009
68010
68011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
68012   void * jresult ;
68013   Dali::Toolkit::ScrollBar *result = 0 ;
68014
68015   {
68016     try {
68017       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
68018     } catch (std::out_of_range& e) {
68019       {
68020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68021       };
68022     } catch (std::exception& e) {
68023       {
68024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68025       };
68026     } catch (...) {
68027       {
68028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68029       };
68030     }
68031   }
68032   jresult = (void *)result;
68033   return jresult;
68034 }
68035
68036
68037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
68038   void * jresult ;
68039   Dali::Toolkit::ScrollBar *arg1 = 0 ;
68040   Dali::Toolkit::ScrollBar *result = 0 ;
68041
68042   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68043   if (!arg1) {
68044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
68045     return 0;
68046   }
68047   {
68048     try {
68049       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
68050     } catch (std::out_of_range& e) {
68051       {
68052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68053       };
68054     } catch (std::exception& e) {
68055       {
68056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68057       };
68058     } catch (...) {
68059       {
68060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68061       };
68062     }
68063   }
68064   jresult = (void *)result;
68065   return jresult;
68066 }
68067
68068
68069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
68070   void * jresult ;
68071   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68072   Dali::Toolkit::ScrollBar *arg2 = 0 ;
68073   Dali::Toolkit::ScrollBar *result = 0 ;
68074
68075   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68076   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
68077   if (!arg2) {
68078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
68079     return 0;
68080   }
68081   {
68082     try {
68083       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
68084     } catch (std::out_of_range& e) {
68085       {
68086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68087       };
68088     } catch (std::exception& e) {
68089       {
68090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68091       };
68092     } catch (...) {
68093       {
68094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68095       };
68096     }
68097   }
68098   jresult = (void *)result;
68099   return jresult;
68100 }
68101
68102
68103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
68104   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68105
68106   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68107   {
68108     try {
68109       delete arg1;
68110     } catch (std::out_of_range& e) {
68111       {
68112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68113       };
68114     } catch (std::exception& e) {
68115       {
68116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68117       };
68118     } catch (...) {
68119       {
68120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68121       };
68122     }
68123   }
68124 }
68125
68126
68127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
68128   void * jresult ;
68129   Dali::Toolkit::ScrollBar::Direction arg1 ;
68130   Dali::Toolkit::ScrollBar result;
68131
68132   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
68133   {
68134     try {
68135       result = Dali::Toolkit::ScrollBar::New(arg1);
68136     } catch (std::out_of_range& e) {
68137       {
68138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68139       };
68140     } catch (std::exception& e) {
68141       {
68142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68143       };
68144     } catch (...) {
68145       {
68146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68147       };
68148     }
68149   }
68150   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
68151   return jresult;
68152 }
68153
68154
68155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
68156   void * jresult ;
68157   Dali::Toolkit::ScrollBar result;
68158
68159   {
68160     try {
68161       result = Dali::Toolkit::ScrollBar::New();
68162     } catch (std::out_of_range& e) {
68163       {
68164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68165       };
68166     } catch (std::exception& e) {
68167       {
68168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68169       };
68170     } catch (...) {
68171       {
68172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68173       };
68174     }
68175   }
68176   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
68177   return jresult;
68178 }
68179
68180
68181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
68182   void * jresult ;
68183   Dali::BaseHandle arg1 ;
68184   Dali::BaseHandle *argp1 ;
68185   Dali::Toolkit::ScrollBar result;
68186
68187   argp1 = (Dali::BaseHandle *)jarg1;
68188   if (!argp1) {
68189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68190     return 0;
68191   }
68192   arg1 = *argp1;
68193   {
68194     try {
68195       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
68196     } catch (std::out_of_range& e) {
68197       {
68198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68199       };
68200     } catch (std::exception& e) {
68201       {
68202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68203       };
68204     } catch (...) {
68205       {
68206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68207       };
68208     }
68209   }
68210   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
68211   return jresult;
68212 }
68213
68214
68215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
68216   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68217   Dali::Handle arg2 ;
68218   Dali::Property::Index arg3 ;
68219   Dali::Property::Index arg4 ;
68220   Dali::Property::Index arg5 ;
68221   Dali::Property::Index arg6 ;
68222   Dali::Handle *argp2 ;
68223
68224   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68225   argp2 = (Dali::Handle *)jarg2;
68226   if (!argp2) {
68227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
68228     return ;
68229   }
68230   arg2 = *argp2;
68231   arg3 = (Dali::Property::Index)jarg3;
68232   arg4 = (Dali::Property::Index)jarg4;
68233   arg5 = (Dali::Property::Index)jarg5;
68234   arg6 = (Dali::Property::Index)jarg6;
68235   {
68236     try {
68237       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
68238     } catch (std::out_of_range& e) {
68239       {
68240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68241       };
68242     } catch (std::exception& e) {
68243       {
68244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68245       };
68246     } catch (...) {
68247       {
68248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68249       };
68250     }
68251   }
68252 }
68253
68254
68255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
68256   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68257   Dali::Actor arg2 ;
68258   Dali::Actor *argp2 ;
68259
68260   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68261   argp2 = (Dali::Actor *)jarg2;
68262   if (!argp2) {
68263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
68264     return ;
68265   }
68266   arg2 = *argp2;
68267   {
68268     try {
68269       (arg1)->SetScrollIndicator(arg2);
68270     } catch (std::out_of_range& e) {
68271       {
68272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68273       };
68274     } catch (std::exception& e) {
68275       {
68276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68277       };
68278     } catch (...) {
68279       {
68280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68281       };
68282     }
68283   }
68284 }
68285
68286
68287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
68288   void * jresult ;
68289   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68290   Dali::Actor result;
68291
68292   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68293   {
68294     try {
68295       result = (arg1)->GetScrollIndicator();
68296     } catch (std::out_of_range& e) {
68297       {
68298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68299       };
68300     } catch (std::exception& e) {
68301       {
68302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68303       };
68304     } catch (...) {
68305       {
68306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68307       };
68308     }
68309   }
68310   jresult = new Dali::Actor((const Dali::Actor &)result);
68311   return jresult;
68312 }
68313
68314
68315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
68316   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68317   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
68318
68319   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68320   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
68321   if (!arg2) {
68322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
68323     return ;
68324   }
68325   {
68326     try {
68327       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
68328     } catch (std::out_of_range& e) {
68329       {
68330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68331       };
68332     } catch (std::exception& e) {
68333       {
68334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68335       };
68336     } catch (...) {
68337       {
68338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68339       };
68340     }
68341   }
68342 }
68343
68344
68345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
68346   void * jresult ;
68347   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68348   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > result;
68349
68350   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68351   {
68352     try {
68353       result = ((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollPositionIntervals();
68354     } catch (std::out_of_range& e) {
68355       {
68356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68357       };
68358     } catch (std::exception& e) {
68359       {
68360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68361       };
68362     } catch (...) {
68363       {
68364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68365       };
68366     }
68367   }
68368   jresult = new Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true >((const Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > &)result);
68369   return jresult;
68370 }
68371
68372
68373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
68374   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68375   Dali::Toolkit::ScrollBar::Direction arg2 ;
68376
68377   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68378   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
68379   {
68380     try {
68381       (arg1)->SetScrollDirection(arg2);
68382     } catch (std::out_of_range& e) {
68383       {
68384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68385       };
68386     } catch (std::exception& e) {
68387       {
68388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68389       };
68390     } catch (...) {
68391       {
68392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68393       };
68394     }
68395   }
68396 }
68397
68398
68399 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
68400   int jresult ;
68401   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68402   Dali::Toolkit::ScrollBar::Direction result;
68403
68404   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68405   {
68406     try {
68407       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
68408     } catch (std::out_of_range& e) {
68409       {
68410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68411       };
68412     } catch (std::exception& e) {
68413       {
68414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68415       };
68416     } catch (...) {
68417       {
68418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68419       };
68420     }
68421   }
68422   jresult = (int)result;
68423   return jresult;
68424 }
68425
68426
68427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
68428   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68429   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
68430
68431   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68432   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
68433   {
68434     try {
68435       (arg1)->SetIndicatorHeightPolicy(arg2);
68436     } catch (std::out_of_range& e) {
68437       {
68438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68439       };
68440     } catch (std::exception& e) {
68441       {
68442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68443       };
68444     } catch (...) {
68445       {
68446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68447       };
68448     }
68449   }
68450 }
68451
68452
68453 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
68454   int jresult ;
68455   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68456   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
68457
68458   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68459   {
68460     try {
68461       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
68462     } catch (std::out_of_range& e) {
68463       {
68464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68465       };
68466     } catch (std::exception& e) {
68467       {
68468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68469       };
68470     } catch (...) {
68471       {
68472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68473       };
68474     }
68475   }
68476   jresult = (int)result;
68477   return jresult;
68478 }
68479
68480
68481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
68482   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68483   float arg2 ;
68484
68485   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68486   arg2 = (float)jarg2;
68487   {
68488     try {
68489       (arg1)->SetIndicatorFixedHeight(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 float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
68508   float jresult ;
68509   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68510   float result;
68511
68512   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68513   {
68514     try {
68515       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
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 = result;
68531   return jresult;
68532 }
68533
68534
68535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
68536   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68537   float arg2 ;
68538
68539   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68540   arg2 = (float)jarg2;
68541   {
68542     try {
68543       (arg1)->SetIndicatorShowDuration(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_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
68562   float jresult ;
68563   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68564   float result;
68565
68566   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68567   {
68568     try {
68569       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
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_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
68590   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68591   float arg2 ;
68592
68593   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68594   arg2 = (float)jarg2;
68595   {
68596     try {
68597       (arg1)->SetIndicatorHideDuration(arg2);
68598     } catch (std::out_of_range& e) {
68599       {
68600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68601       };
68602     } catch (std::exception& e) {
68603       {
68604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68605       };
68606     } catch (...) {
68607       {
68608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68609       };
68610     }
68611   }
68612 }
68613
68614
68615 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
68616   float jresult ;
68617   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68618   float result;
68619
68620   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68621   {
68622     try {
68623       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
68624     } catch (std::out_of_range& e) {
68625       {
68626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68627       };
68628     } catch (std::exception& e) {
68629       {
68630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68631       };
68632     } catch (...) {
68633       {
68634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68635       };
68636     }
68637   }
68638   jresult = result;
68639   return jresult;
68640 }
68641
68642
68643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
68644   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68645
68646   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68647   {
68648     try {
68649       (arg1)->ShowIndicator();
68650     } catch (std::out_of_range& e) {
68651       {
68652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68653       };
68654     } catch (std::exception& e) {
68655       {
68656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68657       };
68658     } catch (...) {
68659       {
68660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68661       };
68662     }
68663   }
68664 }
68665
68666
68667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
68668   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68669
68670   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68671   {
68672     try {
68673       (arg1)->HideIndicator();
68674     } catch (std::out_of_range& e) {
68675       {
68676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68677       };
68678     } catch (std::exception& e) {
68679       {
68680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68681       };
68682     } catch (...) {
68683       {
68684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68685       };
68686     }
68687   }
68688 }
68689
68690
68691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
68692   void * jresult ;
68693   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68694   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
68695
68696   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68697   {
68698     try {
68699       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
68700     } catch (std::out_of_range& e) {
68701       {
68702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68703       };
68704     } catch (std::exception& e) {
68705       {
68706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68707       };
68708     } catch (...) {
68709       {
68710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68711       };
68712     }
68713   }
68714   jresult = (void *)result;
68715   return jresult;
68716 }
68717
68718
68719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
68720   void * jresult ;
68721   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68722   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
68723
68724   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68725   {
68726     try {
68727       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
68728     } catch (std::out_of_range& e) {
68729       {
68730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68731       };
68732     } catch (std::exception& e) {
68733       {
68734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68735       };
68736     } catch (...) {
68737       {
68738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68739       };
68740     }
68741   }
68742   jresult = (void *)result;
68743   return jresult;
68744 }
68745
68746
68747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
68748   int jresult ;
68749   int result;
68750
68751   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
68752   jresult = (int)result;
68753   return jresult;
68754 }
68755
68756
68757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
68758   int jresult ;
68759   int result;
68760
68761   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
68762   jresult = (int)result;
68763   return jresult;
68764 }
68765
68766
68767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
68768   int jresult ;
68769   int result;
68770
68771   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
68772   jresult = (int)result;
68773   return jresult;
68774 }
68775
68776
68777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
68778   int jresult ;
68779   int result;
68780
68781   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
68782   jresult = (int)result;
68783   return jresult;
68784 }
68785
68786
68787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
68788   int jresult ;
68789   int result;
68790
68791   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
68792   jresult = (int)result;
68793   return jresult;
68794 }
68795
68796
68797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
68798   int jresult ;
68799   int result;
68800
68801   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
68802   jresult = (int)result;
68803   return jresult;
68804 }
68805
68806
68807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
68808   int jresult ;
68809   int result;
68810
68811   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
68812   jresult = (int)result;
68813   return jresult;
68814 }
68815
68816
68817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
68818   int jresult ;
68819   int result;
68820
68821   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
68822   jresult = (int)result;
68823   return jresult;
68824 }
68825
68826
68827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
68828   int jresult ;
68829   int result;
68830
68831   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
68832   jresult = (int)result;
68833   return jresult;
68834 }
68835
68836
68837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
68838   int jresult ;
68839   int result;
68840
68841   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
68842   jresult = (int)result;
68843   return jresult;
68844 }
68845
68846
68847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
68848   int jresult ;
68849   int result;
68850
68851   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
68852   jresult = (int)result;
68853   return jresult;
68854 }
68855
68856
68857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
68858   int jresult ;
68859   int result;
68860
68861   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
68862   jresult = (int)result;
68863   return jresult;
68864 }
68865
68866
68867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
68868   int jresult ;
68869   int result;
68870
68871   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
68872   jresult = (int)result;
68873   return jresult;
68874 }
68875
68876
68877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
68878   int jresult ;
68879   int result;
68880
68881   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
68882   jresult = (int)result;
68883   return jresult;
68884 }
68885
68886
68887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
68888   void * jresult ;
68889   Dali::Toolkit::Scrollable::Property *result = 0 ;
68890
68891   {
68892     try {
68893       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
68894     } catch (std::out_of_range& e) {
68895       {
68896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68897       };
68898     } catch (std::exception& e) {
68899       {
68900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68901       };
68902     } catch (...) {
68903       {
68904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68905       };
68906     }
68907   }
68908   jresult = (void *)result;
68909   return jresult;
68910 }
68911
68912
68913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
68914   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
68915
68916   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
68917   {
68918     try {
68919       delete arg1;
68920     } catch (std::out_of_range& e) {
68921       {
68922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68923       };
68924     } catch (std::exception& e) {
68925       {
68926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68927       };
68928     } catch (...) {
68929       {
68930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68931       };
68932     }
68933   }
68934 }
68935
68936
68937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
68938   void * jresult ;
68939   Dali::Toolkit::Scrollable *result = 0 ;
68940
68941   {
68942     try {
68943       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
68944     } catch (std::out_of_range& e) {
68945       {
68946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68947       };
68948     } catch (std::exception& e) {
68949       {
68950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68951       };
68952     } catch (...) {
68953       {
68954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68955       };
68956     }
68957   }
68958   jresult = (void *)result;
68959   return jresult;
68960 }
68961
68962
68963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
68964   void * jresult ;
68965   Dali::Toolkit::Scrollable *arg1 = 0 ;
68966   Dali::Toolkit::Scrollable *result = 0 ;
68967
68968   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68969   if (!arg1) {
68970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68971     return 0;
68972   }
68973   {
68974     try {
68975       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
68976     } catch (std::out_of_range& e) {
68977       {
68978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68979       };
68980     } catch (std::exception& e) {
68981       {
68982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68983       };
68984     } catch (...) {
68985       {
68986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68987       };
68988     }
68989   }
68990   jresult = (void *)result;
68991   return jresult;
68992 }
68993
68994
68995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
68996   void * jresult ;
68997   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68998   Dali::Toolkit::Scrollable *arg2 = 0 ;
68999   Dali::Toolkit::Scrollable *result = 0 ;
69000
69001   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69002   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
69003   if (!arg2) {
69004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
69005     return 0;
69006   }
69007   {
69008     try {
69009       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
69010     } catch (std::out_of_range& e) {
69011       {
69012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69013       };
69014     } catch (std::exception& e) {
69015       {
69016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69017       };
69018     } catch (...) {
69019       {
69020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69021       };
69022     }
69023   }
69024   jresult = (void *)result;
69025   return jresult;
69026 }
69027
69028
69029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
69030   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69031
69032   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69033   {
69034     try {
69035       delete arg1;
69036     } catch (std::out_of_range& e) {
69037       {
69038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69039       };
69040     } catch (std::exception& e) {
69041       {
69042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69043       };
69044     } catch (...) {
69045       {
69046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69047       };
69048     }
69049   }
69050 }
69051
69052
69053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
69054   void * jresult ;
69055   Dali::BaseHandle arg1 ;
69056   Dali::BaseHandle *argp1 ;
69057   Dali::Toolkit::Scrollable result;
69058
69059   argp1 = (Dali::BaseHandle *)jarg1;
69060   if (!argp1) {
69061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69062     return 0;
69063   }
69064   arg1 = *argp1;
69065   {
69066     try {
69067       result = Dali::Toolkit::Scrollable::DownCast(arg1);
69068     } catch (std::out_of_range& e) {
69069       {
69070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69071       };
69072     } catch (std::exception& e) {
69073       {
69074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69075       };
69076     } catch (...) {
69077       {
69078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69079       };
69080     }
69081   }
69082   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
69083   return jresult;
69084 }
69085
69086
69087 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
69088   unsigned int jresult ;
69089   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69090   bool result;
69091
69092   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69093   {
69094     try {
69095       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
69096     } catch (std::out_of_range& e) {
69097       {
69098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69099       };
69100     } catch (std::exception& e) {
69101       {
69102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69103       };
69104     } catch (...) {
69105       {
69106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69107       };
69108     }
69109   }
69110   jresult = result;
69111   return jresult;
69112 }
69113
69114
69115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
69116   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69117   bool arg2 ;
69118
69119   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69120   arg2 = jarg2 ? true : false;
69121   {
69122     try {
69123       (arg1)->SetOvershootEnabled(arg2);
69124     } catch (std::out_of_range& e) {
69125       {
69126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69127       };
69128     } catch (std::exception& e) {
69129       {
69130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69131       };
69132     } catch (...) {
69133       {
69134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69135       };
69136     }
69137   }
69138 }
69139
69140
69141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
69142   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69143   Dali::Vector4 *arg2 = 0 ;
69144
69145   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69146   arg2 = (Dali::Vector4 *)jarg2;
69147   if (!arg2) {
69148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
69149     return ;
69150   }
69151   {
69152     try {
69153       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
69154     } catch (std::out_of_range& e) {
69155       {
69156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69157       };
69158     } catch (std::exception& e) {
69159       {
69160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69161       };
69162     } catch (...) {
69163       {
69164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69165       };
69166     }
69167   }
69168 }
69169
69170
69171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
69172   void * jresult ;
69173   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69174   Dali::Vector4 result;
69175
69176   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69177   {
69178     try {
69179       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
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 = new Dali::Vector4((const Dali::Vector4 &)result);
69195   return jresult;
69196 }
69197
69198
69199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
69200   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69201   float arg2 ;
69202
69203   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69204   arg2 = (float)jarg2;
69205   {
69206     try {
69207       (arg1)->SetOvershootAnimationSpeed(arg2);
69208     } catch (std::out_of_range& e) {
69209       {
69210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69211       };
69212     } catch (std::exception& e) {
69213       {
69214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69215       };
69216     } catch (...) {
69217       {
69218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69219       };
69220     }
69221   }
69222 }
69223
69224
69225 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
69226   float jresult ;
69227   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69228   float result;
69229
69230   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69231   {
69232     try {
69233       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
69234     } catch (std::out_of_range& e) {
69235       {
69236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69237       };
69238     } catch (std::exception& e) {
69239       {
69240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69241       };
69242     } catch (...) {
69243       {
69244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69245       };
69246     }
69247   }
69248   jresult = result;
69249   return jresult;
69250 }
69251
69252
69253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
69254   void * jresult ;
69255   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69256   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
69257
69258   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69259   {
69260     try {
69261       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
69262     } catch (std::out_of_range& e) {
69263       {
69264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69265       };
69266     } catch (std::exception& e) {
69267       {
69268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69269       };
69270     } catch (...) {
69271       {
69272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69273       };
69274     }
69275   }
69276   jresult = (void *)result;
69277   return jresult;
69278 }
69279
69280
69281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
69282   void * jresult ;
69283   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69284   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
69285
69286   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69287   {
69288     try {
69289       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
69290     } catch (std::out_of_range& e) {
69291       {
69292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69293       };
69294     } catch (std::exception& e) {
69295       {
69296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69297       };
69298     } catch (...) {
69299       {
69300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69301       };
69302     }
69303   }
69304   jresult = (void *)result;
69305   return jresult;
69306 }
69307
69308
69309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
69310   void * jresult ;
69311   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69312   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
69313
69314   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69315   {
69316     try {
69317       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
69318     } catch (std::out_of_range& e) {
69319       {
69320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69321       };
69322     } catch (std::exception& e) {
69323       {
69324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69325       };
69326     } catch (...) {
69327       {
69328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69329       };
69330     }
69331   }
69332   jresult = (void *)result;
69333   return jresult;
69334 }
69335
69336
69337 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
69338   unsigned int jresult ;
69339   Dali::Toolkit::ControlOrientation::Type arg1 ;
69340   bool result;
69341
69342   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
69343   {
69344     try {
69345       result = (bool)Dali::Toolkit::IsVertical(arg1);
69346     } catch (std::out_of_range& e) {
69347       {
69348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69349       };
69350     } catch (std::exception& e) {
69351       {
69352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69353       };
69354     } catch (...) {
69355       {
69356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69357       };
69358     }
69359   }
69360   jresult = result;
69361   return jresult;
69362 }
69363
69364
69365 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
69366   unsigned int jresult ;
69367   Dali::Toolkit::ControlOrientation::Type arg1 ;
69368   bool result;
69369
69370   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
69371   {
69372     try {
69373       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
69374     } catch (std::out_of_range& e) {
69375       {
69376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69377       };
69378     } catch (std::exception& e) {
69379       {
69380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69381       };
69382     } catch (...) {
69383       {
69384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69385       };
69386     }
69387   }
69388   jresult = result;
69389   return jresult;
69390 }
69391
69392
69393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
69394   void * jresult ;
69395   unsigned int arg1 ;
69396   unsigned int arg2 ;
69397   Dali::Toolkit::ItemRange *result = 0 ;
69398
69399   arg1 = (unsigned int)jarg1;
69400   arg2 = (unsigned int)jarg2;
69401   {
69402     try {
69403       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
69404     } catch (std::out_of_range& e) {
69405       {
69406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69407       };
69408     } catch (std::exception& e) {
69409       {
69410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69411       };
69412     } catch (...) {
69413       {
69414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69415       };
69416     }
69417   }
69418   jresult = (void *)result;
69419   return jresult;
69420 }
69421
69422
69423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
69424   void * jresult ;
69425   Dali::Toolkit::ItemRange *arg1 = 0 ;
69426   Dali::Toolkit::ItemRange *result = 0 ;
69427
69428   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69429   if (!arg1) {
69430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69431     return 0;
69432   }
69433   {
69434     try {
69435       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
69436     } catch (std::out_of_range& e) {
69437       {
69438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69439       };
69440     } catch (std::exception& e) {
69441       {
69442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69443       };
69444     } catch (...) {
69445       {
69446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69447       };
69448     }
69449   }
69450   jresult = (void *)result;
69451   return jresult;
69452 }
69453
69454
69455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
69456   void * jresult ;
69457   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69458   Dali::Toolkit::ItemRange *arg2 = 0 ;
69459   Dali::Toolkit::ItemRange *result = 0 ;
69460
69461   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69462   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69463   if (!arg2) {
69464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69465     return 0;
69466   }
69467   {
69468     try {
69469       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
69470     } catch (std::out_of_range& e) {
69471       {
69472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69473       };
69474     } catch (std::exception& e) {
69475       {
69476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69477       };
69478     } catch (...) {
69479       {
69480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69481       };
69482     }
69483   }
69484   jresult = (void *)result;
69485   return jresult;
69486 }
69487
69488
69489 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
69490   unsigned int jresult ;
69491   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69492   unsigned int arg2 ;
69493   bool result;
69494
69495   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69496   arg2 = (unsigned int)jarg2;
69497   {
69498     try {
69499       result = (bool)(arg1)->Within(arg2);
69500     } catch (std::out_of_range& e) {
69501       {
69502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69503       };
69504     } catch (std::exception& e) {
69505       {
69506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69507       };
69508     } catch (...) {
69509       {
69510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69511       };
69512     }
69513   }
69514   jresult = result;
69515   return jresult;
69516 }
69517
69518
69519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
69520   void * jresult ;
69521   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69522   Dali::Toolkit::ItemRange *arg2 = 0 ;
69523   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69524
69525   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69526   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69527   if (!arg2) {
69528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69529     return 0;
69530   }
69531   {
69532     try {
69533       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
69534     } catch (std::out_of_range& e) {
69535       {
69536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69537       };
69538     } catch (std::exception& e) {
69539       {
69540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69541       };
69542     } catch (...) {
69543       {
69544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69545       };
69546     }
69547   }
69548   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69549   return jresult;
69550 }
69551
69552
69553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
69554   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69555   unsigned int arg2 ;
69556
69557   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69558   arg2 = (unsigned int)jarg2;
69559   if (arg1) (arg1)->begin = arg2;
69560 }
69561
69562
69563 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
69564   unsigned int jresult ;
69565   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69566   unsigned int result;
69567
69568   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69569   result = (unsigned int) ((arg1)->begin);
69570   jresult = result;
69571   return jresult;
69572 }
69573
69574
69575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
69576   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69577   unsigned int arg2 ;
69578
69579   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69580   arg2 = (unsigned int)jarg2;
69581   if (arg1) (arg1)->end = arg2;
69582 }
69583
69584
69585 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
69586   unsigned int jresult ;
69587   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69588   unsigned int result;
69589
69590   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69591   result = (unsigned int) ((arg1)->end);
69592   jresult = result;
69593   return jresult;
69594 }
69595
69596
69597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
69598   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69599
69600   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69601   {
69602     try {
69603       delete arg1;
69604     } catch (std::out_of_range& e) {
69605       {
69606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69607       };
69608     } catch (std::exception& e) {
69609       {
69610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69611       };
69612     } catch (...) {
69613       {
69614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69615       };
69616     }
69617   }
69618 }
69619
69620
69621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
69622   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69623
69624   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69625   {
69626     try {
69627       delete arg1;
69628     } catch (std::out_of_range& e) {
69629       {
69630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69631       };
69632     } catch (std::exception& e) {
69633       {
69634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69635       };
69636     } catch (...) {
69637       {
69638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69639       };
69640     }
69641   }
69642 }
69643
69644
69645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
69646   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69647   Dali::Toolkit::ControlOrientation::Type arg2 ;
69648
69649   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69650   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
69651   {
69652     try {
69653       (arg1)->SetOrientation(arg2);
69654     } catch (std::out_of_range& e) {
69655       {
69656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69657       };
69658     } catch (std::exception& e) {
69659       {
69660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69661       };
69662     } catch (...) {
69663       {
69664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69665       };
69666     }
69667   }
69668 }
69669
69670
69671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
69672   int jresult ;
69673   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69674   Dali::Toolkit::ControlOrientation::Type result;
69675
69676   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69677   {
69678     try {
69679       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
69680     } catch (std::out_of_range& e) {
69681       {
69682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69683       };
69684     } catch (std::exception& e) {
69685       {
69686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69687       };
69688     } catch (...) {
69689       {
69690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69691       };
69692     }
69693   }
69694   jresult = (int)result;
69695   return jresult;
69696 }
69697
69698
69699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
69700   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69701   Dali::Property::Map *arg2 = 0 ;
69702
69703   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69704   arg2 = (Dali::Property::Map *)jarg2;
69705   if (!arg2) {
69706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
69707     return ;
69708   }
69709   {
69710     try {
69711       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
69712     } catch (std::out_of_range& e) {
69713       {
69714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69715       };
69716     } catch (std::exception& e) {
69717       {
69718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69719       };
69720     } catch (...) {
69721       {
69722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69723       };
69724     }
69725   }
69726 }
69727
69728
69729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
69730   void * jresult ;
69731   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69732   Dali::Property::Map result;
69733
69734   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69735   {
69736     try {
69737       result = (arg1)->GetLayoutProperties();
69738     } catch (std::out_of_range& e) {
69739       {
69740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69741       };
69742     } catch (std::exception& e) {
69743       {
69744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69745       };
69746     } catch (...) {
69747       {
69748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69749       };
69750     }
69751   }
69752   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
69753   return jresult;
69754 }
69755
69756
69757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
69758   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69759   unsigned int arg2 ;
69760   Dali::Vector3 *arg3 = 0 ;
69761   Dali::Vector3 *arg4 = 0 ;
69762
69763   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69764   arg2 = (unsigned int)jarg2;
69765   arg3 = (Dali::Vector3 *)jarg3;
69766   if (!arg3) {
69767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69768     return ;
69769   }
69770   arg4 = (Dali::Vector3 *)jarg4;
69771   if (!arg4) {
69772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69773     return ;
69774   }
69775   {
69776     try {
69777       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
69778     } catch (std::out_of_range& e) {
69779       {
69780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69781       };
69782     } catch (std::exception& e) {
69783       {
69784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69785       };
69786     } catch (...) {
69787       {
69788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69789       };
69790     }
69791   }
69792 }
69793
69794
69795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
69796   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69797   Dali::Vector3 *arg2 = 0 ;
69798
69799   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69800   arg2 = (Dali::Vector3 *)jarg2;
69801   if (!arg2) {
69802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69803     return ;
69804   }
69805   {
69806     try {
69807       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
69808     } catch (std::out_of_range& e) {
69809       {
69810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69811       };
69812     } catch (std::exception& e) {
69813       {
69814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69815       };
69816     } catch (...) {
69817       {
69818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69819       };
69820     }
69821   }
69822 }
69823
69824
69825 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
69826   float jresult ;
69827   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69828   unsigned int arg2 ;
69829   Dali::Vector3 arg3 ;
69830   Dali::Vector3 *argp3 ;
69831   float result;
69832
69833   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69834   arg2 = (unsigned int)jarg2;
69835   argp3 = (Dali::Vector3 *)jarg3;
69836   if (!argp3) {
69837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69838     return 0;
69839   }
69840   arg3 = *argp3;
69841   {
69842     try {
69843       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
69844     } catch (std::out_of_range& e) {
69845       {
69846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69847       };
69848     } catch (std::exception& e) {
69849       {
69850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69851       };
69852     } catch (...) {
69853       {
69854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69855       };
69856     }
69857   }
69858   jresult = result;
69859   return jresult;
69860 }
69861
69862
69863 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
69864   float jresult ;
69865   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69866   float arg2 ;
69867   float result;
69868
69869   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69870   arg2 = (float)jarg2;
69871   {
69872     try {
69873       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
69874     } catch (std::out_of_range& e) {
69875       {
69876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69877       };
69878     } catch (std::exception& e) {
69879       {
69880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69881       };
69882     } catch (...) {
69883       {
69884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69885       };
69886     }
69887   }
69888   jresult = result;
69889   return jresult;
69890 }
69891
69892
69893 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
69894   float jresult ;
69895   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69896   unsigned int arg2 ;
69897   float result;
69898
69899   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69900   arg2 = (unsigned int)jarg2;
69901   {
69902     try {
69903       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
69904     } catch (std::out_of_range& e) {
69905       {
69906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69907       };
69908     } catch (std::exception& e) {
69909       {
69910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69911       };
69912     } catch (...) {
69913       {
69914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69915       };
69916     }
69917   }
69918   jresult = result;
69919   return jresult;
69920 }
69921
69922
69923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
69924   void * jresult ;
69925   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69926   float arg2 ;
69927   Dali::Vector3 arg3 ;
69928   Dali::Vector3 *argp3 ;
69929   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69930
69931   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69932   arg2 = (float)jarg2;
69933   argp3 = (Dali::Vector3 *)jarg3;
69934   if (!argp3) {
69935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69936     return 0;
69937   }
69938   arg3 = *argp3;
69939   {
69940     try {
69941       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
69942     } catch (std::out_of_range& e) {
69943       {
69944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69945       };
69946     } catch (std::exception& e) {
69947       {
69948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69949       };
69950     } catch (...) {
69951       {
69952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69953       };
69954     }
69955   }
69956   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69957   return jresult;
69958 }
69959
69960
69961 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
69962   float jresult ;
69963   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69964   int arg2 ;
69965   float arg3 ;
69966   Dali::Vector3 *arg4 = 0 ;
69967   float result;
69968
69969   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69970   arg2 = (int)jarg2;
69971   arg3 = (float)jarg3;
69972   arg4 = (Dali::Vector3 *)jarg4;
69973   if (!arg4) {
69974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69975     return 0;
69976   }
69977   {
69978     try {
69979       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
69980     } catch (std::out_of_range& e) {
69981       {
69982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69983       };
69984     } catch (std::exception& e) {
69985       {
69986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69987       };
69988     } catch (...) {
69989       {
69990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69991       };
69992     }
69993   }
69994   jresult = result;
69995   return jresult;
69996 }
69997
69998
69999 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
70000   unsigned int jresult ;
70001   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70002   Dali::Vector3 arg2 ;
70003   Dali::Vector3 *argp2 ;
70004   unsigned int result;
70005
70006   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70007   argp2 = (Dali::Vector3 *)jarg2;
70008   if (!argp2) {
70009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
70010     return 0;
70011   }
70012   arg2 = *argp2;
70013   {
70014     try {
70015       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
70016     } catch (std::out_of_range& e) {
70017       {
70018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70019       };
70020     } catch (std::exception& e) {
70021       {
70022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70023       };
70024     } catch (...) {
70025       {
70026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70027       };
70028     }
70029   }
70030   jresult = result;
70031   return jresult;
70032 }
70033
70034
70035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
70036   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70037   unsigned int arg2 ;
70038   Dali::Vector3 *arg3 = 0 ;
70039   Dali::Vector3 *arg4 = 0 ;
70040
70041   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70042   arg2 = (unsigned int)jarg2;
70043   arg3 = (Dali::Vector3 *)jarg3;
70044   if (!arg3) {
70045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70046     return ;
70047   }
70048   arg4 = (Dali::Vector3 *)jarg4;
70049   if (!arg4) {
70050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
70051     return ;
70052   }
70053   {
70054     try {
70055       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
70056     } catch (std::out_of_range& e) {
70057       {
70058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70059       };
70060     } catch (std::exception& e) {
70061       {
70062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70063       };
70064     } catch (...) {
70065       {
70066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70067       };
70068     }
70069   }
70070 }
70071
70072
70073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
70074   void * jresult ;
70075   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70076   Dali::Degree result;
70077
70078   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70079   {
70080     try {
70081       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
70082     } catch (std::out_of_range& e) {
70083       {
70084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70085       };
70086     } catch (std::exception& e) {
70087       {
70088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70089       };
70090     } catch (...) {
70091       {
70092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70093       };
70094     }
70095   }
70096   jresult = new Dali::Degree((const Dali::Degree &)result);
70097   return jresult;
70098 }
70099
70100
70101 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
70102   float jresult ;
70103   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70104   float result;
70105
70106   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70107   {
70108     try {
70109       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
70110     } catch (std::out_of_range& e) {
70111       {
70112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70113       };
70114     } catch (std::exception& e) {
70115       {
70116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70117       };
70118     } catch (...) {
70119       {
70120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70121       };
70122     }
70123   }
70124   jresult = result;
70125   return jresult;
70126 }
70127
70128
70129 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
70130   float jresult ;
70131   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70132   float result;
70133
70134   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70135   {
70136     try {
70137       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
70138     } catch (std::out_of_range& e) {
70139       {
70140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70141       };
70142     } catch (std::exception& e) {
70143       {
70144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70145       };
70146     } catch (...) {
70147       {
70148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70149       };
70150     }
70151   }
70152   jresult = result;
70153   return jresult;
70154 }
70155
70156
70157 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
70158   float jresult ;
70159   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70160   float result;
70161
70162   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70163   {
70164     try {
70165       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
70166     } catch (std::out_of_range& e) {
70167       {
70168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70169       };
70170     } catch (std::exception& e) {
70171       {
70172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70173       };
70174     } catch (...) {
70175       {
70176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70177       };
70178     }
70179   }
70180   jresult = result;
70181   return jresult;
70182 }
70183
70184
70185 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
70186   int jresult ;
70187   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70188   int arg2 ;
70189   int arg3 ;
70190   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
70191   bool arg5 ;
70192   int result;
70193
70194   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70195   arg2 = (int)jarg2;
70196   arg3 = (int)jarg3;
70197   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
70198   arg5 = jarg5 ? true : false;
70199   {
70200     try {
70201       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
70202     } catch (std::out_of_range& e) {
70203       {
70204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70205       };
70206     } catch (std::exception& e) {
70207       {
70208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70209       };
70210     } catch (...) {
70211       {
70212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70213       };
70214     }
70215   }
70216   jresult = result;
70217   return jresult;
70218 }
70219
70220
70221 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
70222   float jresult ;
70223   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70224   float result;
70225
70226   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70227   {
70228     try {
70229       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
70230     } catch (std::out_of_range& e) {
70231       {
70232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70233       };
70234     } catch (std::exception& e) {
70235       {
70236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70237       };
70238     } catch (...) {
70239       {
70240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70241       };
70242     }
70243   }
70244   jresult = result;
70245   return jresult;
70246 }
70247
70248
70249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
70250   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70251   Dali::Actor *arg2 = 0 ;
70252   int arg3 ;
70253   Dali::Vector3 *arg4 = 0 ;
70254   Dali::Actor *arg5 = 0 ;
70255
70256   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70257   arg2 = (Dali::Actor *)jarg2;
70258   if (!arg2) {
70259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
70260     return ;
70261   }
70262   arg3 = (int)jarg3;
70263   arg4 = (Dali::Vector3 *)jarg4;
70264   if (!arg4) {
70265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70266     return ;
70267   }
70268   arg5 = (Dali::Actor *)jarg5;
70269   if (!arg5) {
70270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
70271     return ;
70272   }
70273   {
70274     try {
70275       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
70276     } catch (std::out_of_range& e) {
70277       {
70278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70279       };
70280     } catch (std::exception& e) {
70281       {
70282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70283       };
70284     } catch (...) {
70285       {
70286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70287       };
70288     }
70289   }
70290 }
70291
70292
70293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
70294   void * jresult ;
70295   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70296   int arg2 ;
70297   float arg3 ;
70298   Dali::Vector3 *arg4 = 0 ;
70299   Dali::Vector3 result;
70300
70301   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70302   arg2 = (int)jarg2;
70303   arg3 = (float)jarg3;
70304   arg4 = (Dali::Vector3 *)jarg4;
70305   if (!arg4) {
70306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70307     return 0;
70308   }
70309   {
70310     try {
70311       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
70312     } catch (std::out_of_range& e) {
70313       {
70314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70315       };
70316     } catch (std::exception& e) {
70317       {
70318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70319       };
70320     } catch (...) {
70321       {
70322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70323       };
70324     }
70325   }
70326   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
70327   return jresult;
70328 }
70329
70330
70331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
70332   void * jresult ;
70333   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
70334   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70335
70336   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
70337   {
70338     try {
70339       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
70340     } catch (std::out_of_range& e) {
70341       {
70342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70343       };
70344     } catch (std::exception& e) {
70345       {
70346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70347       };
70348     } catch (...) {
70349       {
70350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70351       };
70352     }
70353   }
70354   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70355   return jresult;
70356 }
70357
70358
70359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
70360   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70361
70362   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70363   {
70364     try {
70365       delete arg1;
70366     } catch (std::out_of_range& e) {
70367       {
70368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70369       };
70370     } catch (std::exception& e) {
70371       {
70372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70373       };
70374     } catch (...) {
70375       {
70376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70377       };
70378     }
70379   }
70380 }
70381
70382
70383 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
70384   unsigned int jresult ;
70385   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70386   unsigned int result;
70387
70388   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70389   {
70390     try {
70391       result = (unsigned int)(arg1)->GetNumberOfItems();
70392     } catch (std::out_of_range& e) {
70393       {
70394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70395       };
70396     } catch (std::exception& e) {
70397       {
70398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70399       };
70400     } catch (...) {
70401       {
70402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70403       };
70404     }
70405   }
70406   jresult = result;
70407   return jresult;
70408 }
70409
70410
70411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
70412   void * jresult ;
70413   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70414   unsigned int arg2 ;
70415   Dali::Actor result;
70416
70417   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70418   arg2 = (unsigned int)jarg2;
70419   {
70420     try {
70421       result = (arg1)->NewItem(arg2);
70422     } catch (std::out_of_range& e) {
70423       {
70424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70425       };
70426     } catch (std::exception& e) {
70427       {
70428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70429       };
70430     } catch (...) {
70431       {
70432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70433       };
70434     }
70435   }
70436   jresult = new Dali::Actor((const Dali::Actor &)result);
70437   return jresult;
70438 }
70439
70440
70441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
70442   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70443   unsigned int arg2 ;
70444   Dali::Actor arg3 ;
70445   Dali::Actor *argp3 ;
70446
70447   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70448   arg2 = (unsigned int)jarg2;
70449   argp3 = (Dali::Actor *)jarg3;
70450   if (!argp3) {
70451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70452     return ;
70453   }
70454   arg3 = *argp3;
70455   {
70456     try {
70457       (arg1)->ItemReleased(arg2,arg3);
70458     } catch (std::out_of_range& e) {
70459       {
70460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70461       };
70462     } catch (std::exception& e) {
70463       {
70464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70465       };
70466     } catch (...) {
70467       {
70468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70469       };
70470     }
70471   }
70472 }
70473
70474
70475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
70476   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70477   unsigned int arg2 ;
70478   Dali::Actor arg3 ;
70479   Dali::Actor *argp3 ;
70480
70481   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70482   arg2 = (unsigned int)jarg2;
70483   argp3 = (Dali::Actor *)jarg3;
70484   if (!argp3) {
70485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70486     return ;
70487   }
70488   arg3 = *argp3;
70489   {
70490     try {
70491       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
70492     } catch (std::out_of_range& e) {
70493       {
70494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70495       };
70496     } catch (std::exception& e) {
70497       {
70498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70499       };
70500     } catch (...) {
70501       {
70502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70503       };
70504     }
70505   }
70506 }
70507
70508
70509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
70510   void * jresult ;
70511   Dali::Toolkit::ItemFactory *result = 0 ;
70512
70513   {
70514     try {
70515       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
70516     } catch (std::out_of_range& e) {
70517       {
70518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70519       };
70520     } catch (std::exception& e) {
70521       {
70522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70523       };
70524     } catch (...) {
70525       {
70526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70527       };
70528     }
70529   }
70530   jresult = (void *)result;
70531   return jresult;
70532 }
70533
70534
70535 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) {
70536   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
70537   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
70538   if (director) {
70539     director->swig_connect_director(callback0, callback1, callback2);
70540   }
70541 }
70542
70543
70544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
70545   int jresult ;
70546   int result;
70547
70548   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
70549   jresult = (int)result;
70550   return jresult;
70551 }
70552
70553
70554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
70555   int jresult ;
70556   int result;
70557
70558   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
70559   jresult = (int)result;
70560   return jresult;
70561 }
70562
70563
70564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
70565   int jresult ;
70566   int result;
70567
70568   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
70569   jresult = (int)result;
70570   return jresult;
70571 }
70572
70573
70574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
70575   int jresult ;
70576   int result;
70577
70578   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
70579   jresult = (int)result;
70580   return jresult;
70581 }
70582
70583
70584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
70585   int jresult ;
70586   int result;
70587
70588   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
70589   jresult = (int)result;
70590   return jresult;
70591 }
70592
70593
70594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
70595   int jresult ;
70596   int result;
70597
70598   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
70599   jresult = (int)result;
70600   return jresult;
70601 }
70602
70603
70604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
70605   int jresult ;
70606   int result;
70607
70608   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
70609   jresult = (int)result;
70610   return jresult;
70611 }
70612
70613
70614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
70615   int jresult ;
70616   int result;
70617
70618   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
70619   jresult = (int)result;
70620   return jresult;
70621 }
70622
70623
70624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
70625   int jresult ;
70626   int result;
70627
70628   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
70629   jresult = (int)result;
70630   return jresult;
70631 }
70632
70633
70634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
70635   int jresult ;
70636   int result;
70637
70638   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
70639   jresult = (int)result;
70640   return jresult;
70641 }
70642
70643
70644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
70645   int jresult ;
70646   int result;
70647
70648   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
70649   jresult = (int)result;
70650   return jresult;
70651 }
70652
70653
70654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
70655   void * jresult ;
70656   Dali::Toolkit::ItemView::Property *result = 0 ;
70657
70658   {
70659     try {
70660       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
70661     } catch (std::out_of_range& e) {
70662       {
70663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70664       };
70665     } catch (std::exception& e) {
70666       {
70667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70668       };
70669     } catch (...) {
70670       {
70671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70672       };
70673     }
70674   }
70675   jresult = (void *)result;
70676   return jresult;
70677 }
70678
70679
70680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
70681   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
70682
70683   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
70684   {
70685     try {
70686       delete arg1;
70687     } catch (std::out_of_range& e) {
70688       {
70689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70690       };
70691     } catch (std::exception& e) {
70692       {
70693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70694       };
70695     } catch (...) {
70696       {
70697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70698       };
70699     }
70700   }
70701 }
70702
70703
70704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
70705   void * jresult ;
70706   Dali::Toolkit::ItemView *result = 0 ;
70707
70708   {
70709     try {
70710       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
70711     } catch (std::out_of_range& e) {
70712       {
70713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70714       };
70715     } catch (std::exception& e) {
70716       {
70717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70718       };
70719     } catch (...) {
70720       {
70721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70722       };
70723     }
70724   }
70725   jresult = (void *)result;
70726   return jresult;
70727 }
70728
70729
70730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
70731   void * jresult ;
70732   Dali::Toolkit::ItemView *arg1 = 0 ;
70733   Dali::Toolkit::ItemView *result = 0 ;
70734
70735   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70736   if (!arg1) {
70737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70738     return 0;
70739   }
70740   {
70741     try {
70742       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
70743     } catch (std::out_of_range& e) {
70744       {
70745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70746       };
70747     } catch (std::exception& e) {
70748       {
70749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70750       };
70751     } catch (...) {
70752       {
70753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70754       };
70755     }
70756   }
70757   jresult = (void *)result;
70758   return jresult;
70759 }
70760
70761
70762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
70763   void * jresult ;
70764   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70765   Dali::Toolkit::ItemView *arg2 = 0 ;
70766   Dali::Toolkit::ItemView *result = 0 ;
70767
70768   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70769   arg2 = (Dali::Toolkit::ItemView *)jarg2;
70770   if (!arg2) {
70771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70772     return 0;
70773   }
70774   {
70775     try {
70776       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
70777     } catch (std::out_of_range& e) {
70778       {
70779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70780       };
70781     } catch (std::exception& e) {
70782       {
70783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70784       };
70785     } catch (...) {
70786       {
70787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70788       };
70789     }
70790   }
70791   jresult = (void *)result;
70792   return jresult;
70793 }
70794
70795
70796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
70797   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70798
70799   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70800   {
70801     try {
70802       delete arg1;
70803     } catch (std::out_of_range& e) {
70804       {
70805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70806       };
70807     } catch (std::exception& e) {
70808       {
70809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70810       };
70811     } catch (...) {
70812       {
70813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70814       };
70815     }
70816   }
70817 }
70818
70819
70820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
70821   void * jresult ;
70822   Dali::Toolkit::ItemFactory *arg1 = 0 ;
70823   Dali::Toolkit::ItemView result;
70824
70825   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70826   if (!arg1) {
70827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
70828     return 0;
70829   }
70830   {
70831     try {
70832       result = Dali::Toolkit::ItemView::New(*arg1);
70833     } catch (std::out_of_range& e) {
70834       {
70835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70836       };
70837     } catch (std::exception& e) {
70838       {
70839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70840       };
70841     } catch (...) {
70842       {
70843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70844       };
70845     }
70846   }
70847   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
70848   return jresult;
70849 }
70850
70851
70852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
70853   void * jresult ;
70854   Dali::BaseHandle arg1 ;
70855   Dali::BaseHandle *argp1 ;
70856   Dali::Toolkit::ItemView result;
70857
70858   argp1 = (Dali::BaseHandle *)jarg1;
70859   if (!argp1) {
70860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70861     return 0;
70862   }
70863   arg1 = *argp1;
70864   {
70865     try {
70866       result = Dali::Toolkit::ItemView::DownCast(arg1);
70867     } catch (std::out_of_range& e) {
70868       {
70869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70870       };
70871     } catch (std::exception& e) {
70872       {
70873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70874       };
70875     } catch (...) {
70876       {
70877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70878       };
70879     }
70880   }
70881   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
70882   return jresult;
70883 }
70884
70885
70886 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
70887   unsigned int jresult ;
70888   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70889   unsigned int result;
70890
70891   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70892   {
70893     try {
70894       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
70895     } catch (std::out_of_range& e) {
70896       {
70897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70898       };
70899     } catch (std::exception& e) {
70900       {
70901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70902       };
70903     } catch (...) {
70904       {
70905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70906       };
70907     }
70908   }
70909   jresult = result;
70910   return jresult;
70911 }
70912
70913
70914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
70915   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70916   Dali::Toolkit::ItemLayout *arg2 = 0 ;
70917
70918   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70919   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
70920   if (!arg2) {
70921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
70922     return ;
70923   }
70924   {
70925     try {
70926       (arg1)->AddLayout(*arg2);
70927     } catch (std::out_of_range& e) {
70928       {
70929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70930       };
70931     } catch (std::exception& e) {
70932       {
70933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70934       };
70935     } catch (...) {
70936       {
70937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70938       };
70939     }
70940   }
70941 }
70942
70943
70944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
70945   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70946   unsigned int arg2 ;
70947
70948   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70949   arg2 = (unsigned int)jarg2;
70950   {
70951     try {
70952       (arg1)->RemoveLayout(arg2);
70953     } catch (std::out_of_range& e) {
70954       {
70955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70956       };
70957     } catch (std::exception& e) {
70958       {
70959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70960       };
70961     } catch (...) {
70962       {
70963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70964       };
70965     }
70966   }
70967 }
70968
70969
70970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
70971   void * jresult ;
70972   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70973   unsigned int arg2 ;
70974   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70975
70976   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70977   arg2 = (unsigned int)jarg2;
70978   {
70979     try {
70980       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
70981     } catch (std::out_of_range& e) {
70982       {
70983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70984       };
70985     } catch (std::exception& e) {
70986       {
70987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70988       };
70989     } catch (...) {
70990       {
70991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70992       };
70993     }
70994   }
70995   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70996   return jresult;
70997 }
70998
70999
71000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
71001   void * jresult ;
71002   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71003   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
71004
71005   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71006   {
71007     try {
71008       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
71009     } catch (std::out_of_range& e) {
71010       {
71011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71012       };
71013     } catch (std::exception& e) {
71014       {
71015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71016       };
71017     } catch (...) {
71018       {
71019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71020       };
71021     }
71022   }
71023   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
71024   return jresult;
71025 }
71026
71027
71028 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
71029   float jresult ;
71030   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71031   Dali::Toolkit::ItemId arg2 ;
71032   float result;
71033
71034   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71035   arg2 = (Dali::Toolkit::ItemId)jarg2;
71036   {
71037     try {
71038       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
71039     } catch (std::out_of_range& e) {
71040       {
71041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71042       };
71043     } catch (std::exception& e) {
71044       {
71045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71046       };
71047     } catch (...) {
71048       {
71049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71050       };
71051     }
71052   }
71053   jresult = result;
71054   return jresult;
71055 }
71056
71057
71058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
71059   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71060   unsigned int arg2 ;
71061   Dali::Vector3 arg3 ;
71062   float arg4 ;
71063   Dali::Vector3 *argp3 ;
71064
71065   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71066   arg2 = (unsigned int)jarg2;
71067   argp3 = (Dali::Vector3 *)jarg3;
71068   if (!argp3) {
71069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
71070     return ;
71071   }
71072   arg3 = *argp3;
71073   arg4 = (float)jarg4;
71074   {
71075     try {
71076       (arg1)->ActivateLayout(arg2,arg3,arg4);
71077     } catch (std::out_of_range& e) {
71078       {
71079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71080       };
71081     } catch (std::exception& e) {
71082       {
71083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71084       };
71085     } catch (...) {
71086       {
71087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71088       };
71089     }
71090   }
71091 }
71092
71093
71094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
71095   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71096
71097   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71098   {
71099     try {
71100       (arg1)->DeactivateCurrentLayout();
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_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
71119   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71120   float arg2 ;
71121
71122   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71123   arg2 = (float)jarg2;
71124   {
71125     try {
71126       (arg1)->SetMinimumSwipeSpeed(arg2);
71127     } catch (std::out_of_range& e) {
71128       {
71129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71130       };
71131     } catch (std::exception& e) {
71132       {
71133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71134       };
71135     } catch (...) {
71136       {
71137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71138       };
71139     }
71140   }
71141 }
71142
71143
71144 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
71145   float jresult ;
71146   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71147   float result;
71148
71149   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71150   {
71151     try {
71152       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
71153     } catch (std::out_of_range& e) {
71154       {
71155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71156       };
71157     } catch (std::exception& e) {
71158       {
71159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71160       };
71161     } catch (...) {
71162       {
71163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71164       };
71165     }
71166   }
71167   jresult = result;
71168   return jresult;
71169 }
71170
71171
71172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
71173   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71174   float arg2 ;
71175
71176   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71177   arg2 = (float)jarg2;
71178   {
71179     try {
71180       (arg1)->SetMinimumSwipeDistance(arg2);
71181     } catch (std::out_of_range& e) {
71182       {
71183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71184       };
71185     } catch (std::exception& e) {
71186       {
71187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71188       };
71189     } catch (...) {
71190       {
71191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71192       };
71193     }
71194   }
71195 }
71196
71197
71198 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
71199   float jresult ;
71200   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71201   float result;
71202
71203   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71204   {
71205     try {
71206       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
71207     } catch (std::out_of_range& e) {
71208       {
71209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71210       };
71211     } catch (std::exception& e) {
71212       {
71213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71214       };
71215     } catch (...) {
71216       {
71217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71218       };
71219     }
71220   }
71221   jresult = result;
71222   return jresult;
71223 }
71224
71225
71226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
71227   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71228   float arg2 ;
71229
71230   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71231   arg2 = (float)jarg2;
71232   {
71233     try {
71234       (arg1)->SetWheelScrollDistanceStep(arg2);
71235     } catch (std::out_of_range& e) {
71236       {
71237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71238       };
71239     } catch (std::exception& e) {
71240       {
71241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71242       };
71243     } catch (...) {
71244       {
71245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71246       };
71247     }
71248   }
71249 }
71250
71251
71252 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
71253   float jresult ;
71254   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71255   float result;
71256
71257   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71258   {
71259     try {
71260       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
71261     } catch (std::out_of_range& e) {
71262       {
71263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71264       };
71265     } catch (std::exception& e) {
71266       {
71267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71268       };
71269     } catch (...) {
71270       {
71271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71272       };
71273     }
71274   }
71275   jresult = result;
71276   return jresult;
71277 }
71278
71279
71280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
71281   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71282   bool arg2 ;
71283
71284   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71285   arg2 = jarg2 ? true : false;
71286   {
71287     try {
71288       (arg1)->SetAnchoring(arg2);
71289     } catch (std::out_of_range& e) {
71290       {
71291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71292       };
71293     } catch (std::exception& e) {
71294       {
71295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71296       };
71297     } catch (...) {
71298       {
71299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71300       };
71301     }
71302   }
71303 }
71304
71305
71306 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
71307   unsigned int jresult ;
71308   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71309   bool result;
71310
71311   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71312   {
71313     try {
71314       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
71315     } catch (std::out_of_range& e) {
71316       {
71317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71318       };
71319     } catch (std::exception& e) {
71320       {
71321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71322       };
71323     } catch (...) {
71324       {
71325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71326       };
71327     }
71328   }
71329   jresult = result;
71330   return jresult;
71331 }
71332
71333
71334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
71335   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71336   float arg2 ;
71337
71338   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71339   arg2 = (float)jarg2;
71340   {
71341     try {
71342       (arg1)->SetAnchoringDuration(arg2);
71343     } catch (std::out_of_range& e) {
71344       {
71345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71346       };
71347     } catch (std::exception& e) {
71348       {
71349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71350       };
71351     } catch (...) {
71352       {
71353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71354       };
71355     }
71356   }
71357 }
71358
71359
71360 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
71361   float jresult ;
71362   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71363   float result;
71364
71365   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71366   {
71367     try {
71368       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
71369     } catch (std::out_of_range& e) {
71370       {
71371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71372       };
71373     } catch (std::exception& e) {
71374       {
71375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71376       };
71377     } catch (...) {
71378       {
71379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71380       };
71381     }
71382   }
71383   jresult = result;
71384   return jresult;
71385 }
71386
71387
71388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
71389   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71390   Dali::Toolkit::ItemId arg2 ;
71391   float arg3 ;
71392
71393   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71394   arg2 = (Dali::Toolkit::ItemId)jarg2;
71395   arg3 = (float)jarg3;
71396   {
71397     try {
71398       (arg1)->ScrollToItem(arg2,arg3);
71399     } catch (std::out_of_range& e) {
71400       {
71401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71402       };
71403     } catch (std::exception& e) {
71404       {
71405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71406       };
71407     } catch (...) {
71408       {
71409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71410       };
71411     }
71412   }
71413 }
71414
71415
71416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
71417   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71418   float arg2 ;
71419
71420   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71421   arg2 = (float)jarg2;
71422   {
71423     try {
71424       (arg1)->SetRefreshInterval(arg2);
71425     } catch (std::out_of_range& e) {
71426       {
71427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71428       };
71429     } catch (std::exception& e) {
71430       {
71431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71432       };
71433     } catch (...) {
71434       {
71435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71436       };
71437     }
71438   }
71439 }
71440
71441
71442 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
71443   float jresult ;
71444   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71445   float result;
71446
71447   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71448   {
71449     try {
71450       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
71451     } catch (std::out_of_range& e) {
71452       {
71453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71454       };
71455     } catch (std::exception& e) {
71456       {
71457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71458       };
71459     } catch (...) {
71460       {
71461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71462       };
71463     }
71464   }
71465   jresult = result;
71466   return jresult;
71467 }
71468
71469
71470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
71471   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71472
71473   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71474   {
71475     try {
71476       (arg1)->Refresh();
71477     } catch (std::out_of_range& e) {
71478       {
71479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71480       };
71481     } catch (std::exception& e) {
71482       {
71483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71484       };
71485     } catch (...) {
71486       {
71487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71488       };
71489     }
71490   }
71491 }
71492
71493
71494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
71495   void * jresult ;
71496   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71497   Dali::Toolkit::ItemId arg2 ;
71498   Dali::Actor result;
71499
71500   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71501   arg2 = (Dali::Toolkit::ItemId)jarg2;
71502   {
71503     try {
71504       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
71505     } catch (std::out_of_range& e) {
71506       {
71507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71508       };
71509     } catch (std::exception& e) {
71510       {
71511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71512       };
71513     } catch (...) {
71514       {
71515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71516       };
71517     }
71518   }
71519   jresult = new Dali::Actor((const Dali::Actor &)result);
71520   return jresult;
71521 }
71522
71523
71524 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
71525   unsigned int jresult ;
71526   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71527   Dali::Actor arg2 ;
71528   Dali::Actor *argp2 ;
71529   Dali::Toolkit::ItemId result;
71530
71531   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71532   argp2 = (Dali::Actor *)jarg2;
71533   if (!argp2) {
71534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71535     return 0;
71536   }
71537   arg2 = *argp2;
71538   {
71539     try {
71540       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
71541     } catch (std::out_of_range& e) {
71542       {
71543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71544       };
71545     } catch (std::exception& e) {
71546       {
71547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71548       };
71549     } catch (...) {
71550       {
71551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71552       };
71553     }
71554   }
71555   jresult = result;
71556   return jresult;
71557 }
71558
71559
71560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
71561   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71562   Dali::Toolkit::Item arg2 ;
71563   float arg3 ;
71564   Dali::Toolkit::Item *argp2 ;
71565
71566   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71567   argp2 = (Dali::Toolkit::Item *)jarg2;
71568   if (!argp2) {
71569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71570     return ;
71571   }
71572   arg2 = *argp2;
71573   arg3 = (float)jarg3;
71574   {
71575     try {
71576       (arg1)->InsertItem(arg2,arg3);
71577     } catch (std::out_of_range& e) {
71578       {
71579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71580       };
71581     } catch (std::exception& e) {
71582       {
71583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71584       };
71585     } catch (...) {
71586       {
71587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71588       };
71589     }
71590   }
71591 }
71592
71593
71594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
71595   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71596   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71597   float arg3 ;
71598
71599   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71600   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71601   if (!arg2) {
71602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71603     return ;
71604   }
71605   arg3 = (float)jarg3;
71606   {
71607     try {
71608       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71609     } catch (std::out_of_range& e) {
71610       {
71611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71612       };
71613     } catch (std::exception& e) {
71614       {
71615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71616       };
71617     } catch (...) {
71618       {
71619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71620       };
71621     }
71622   }
71623 }
71624
71625
71626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
71627   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71628   Dali::Toolkit::ItemId arg2 ;
71629   float arg3 ;
71630
71631   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71632   arg2 = (Dali::Toolkit::ItemId)jarg2;
71633   arg3 = (float)jarg3;
71634   {
71635     try {
71636       (arg1)->RemoveItem(arg2,arg3);
71637     } catch (std::out_of_range& e) {
71638       {
71639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71640       };
71641     } catch (std::exception& e) {
71642       {
71643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71644       };
71645     } catch (...) {
71646       {
71647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71648       };
71649     }
71650   }
71651 }
71652
71653
71654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
71655   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71656   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
71657   float arg3 ;
71658
71659   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71660   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
71661   if (!arg2) {
71662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
71663     return ;
71664   }
71665   arg3 = (float)jarg3;
71666   {
71667     try {
71668       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
71669     } catch (std::out_of_range& e) {
71670       {
71671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71672       };
71673     } catch (std::exception& e) {
71674       {
71675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71676       };
71677     } catch (...) {
71678       {
71679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71680       };
71681     }
71682   }
71683 }
71684
71685
71686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
71687   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71688   Dali::Toolkit::Item arg2 ;
71689   float arg3 ;
71690   Dali::Toolkit::Item *argp2 ;
71691
71692   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71693   argp2 = (Dali::Toolkit::Item *)jarg2;
71694   if (!argp2) {
71695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71696     return ;
71697   }
71698   arg2 = *argp2;
71699   arg3 = (float)jarg3;
71700   {
71701     try {
71702       (arg1)->ReplaceItem(arg2,arg3);
71703     } catch (std::out_of_range& e) {
71704       {
71705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71706       };
71707     } catch (std::exception& e) {
71708       {
71709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71710       };
71711     } catch (...) {
71712       {
71713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71714       };
71715     }
71716   }
71717 }
71718
71719
71720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
71721   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71722   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71723   float arg3 ;
71724
71725   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71726   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71727   if (!arg2) {
71728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71729     return ;
71730   }
71731   arg3 = (float)jarg3;
71732   {
71733     try {
71734       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71735     } catch (std::out_of_range& e) {
71736       {
71737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71738       };
71739     } catch (std::exception& e) {
71740       {
71741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71742       };
71743     } catch (...) {
71744       {
71745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71746       };
71747     }
71748   }
71749 }
71750
71751
71752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
71753   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71754   Dali::Vector3 *arg2 = 0 ;
71755
71756   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71757   arg2 = (Dali::Vector3 *)jarg2;
71758   if (!arg2) {
71759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71760     return ;
71761   }
71762   {
71763     try {
71764       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
71765     } catch (std::out_of_range& e) {
71766       {
71767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71768       };
71769     } catch (std::exception& e) {
71770       {
71771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71772       };
71773     } catch (...) {
71774       {
71775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71776       };
71777     }
71778   }
71779 }
71780
71781
71782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
71783   void * jresult ;
71784   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71785   Dali::Vector3 result;
71786
71787   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71788   {
71789     try {
71790       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
71791     } catch (std::out_of_range& e) {
71792       {
71793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71794       };
71795     } catch (std::exception& e) {
71796       {
71797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71798       };
71799     } catch (...) {
71800       {
71801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71802       };
71803     }
71804   }
71805   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
71806   return jresult;
71807 }
71808
71809
71810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
71811   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71812   Dali::Vector3 *arg2 = 0 ;
71813
71814   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71815   arg2 = (Dali::Vector3 *)jarg2;
71816   if (!arg2) {
71817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71818     return ;
71819   }
71820   {
71821     try {
71822       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
71823     } catch (std::out_of_range& e) {
71824       {
71825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71826       };
71827     } catch (std::exception& e) {
71828       {
71829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71830       };
71831     } catch (...) {
71832       {
71833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71834       };
71835     }
71836   }
71837 }
71838
71839
71840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
71841   void * jresult ;
71842   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71843   Dali::Vector3 result;
71844
71845   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71846   {
71847     try {
71848       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
71849     } catch (std::out_of_range& e) {
71850       {
71851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71852       };
71853     } catch (std::exception& e) {
71854       {
71855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71856       };
71857     } catch (...) {
71858       {
71859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71860       };
71861     }
71862   }
71863   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
71864   return jresult;
71865 }
71866
71867
71868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
71869   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71870   Dali::Toolkit::ItemRange *arg2 = 0 ;
71871
71872   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71873   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
71874   if (!arg2) {
71875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
71876     return ;
71877   }
71878   {
71879     try {
71880       (arg1)->GetItemsRange(*arg2);
71881     } catch (std::out_of_range& e) {
71882       {
71883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71884       };
71885     } catch (std::exception& e) {
71886       {
71887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71888       };
71889     } catch (...) {
71890       {
71891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71892       };
71893     }
71894   }
71895 }
71896
71897
71898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
71899   void * jresult ;
71900   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71901   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
71902
71903   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71904   {
71905     try {
71906       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
71907     } catch (std::out_of_range& e) {
71908       {
71909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71910       };
71911     } catch (std::exception& e) {
71912       {
71913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71914       };
71915     } catch (...) {
71916       {
71917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71918       };
71919     }
71920   }
71921   jresult = (void *)result;
71922   return jresult;
71923 }
71924
71925
71926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
71927   Dali::Vector3 *arg1 = 0 ;
71928   PropertyInputContainer *arg2 = 0 ;
71929
71930   arg1 = (Dali::Vector3 *)jarg1;
71931   if (!arg1) {
71932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
71933     return ;
71934   }
71935   arg2 = (PropertyInputContainer *)jarg2;
71936   if (!arg2) {
71937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
71938     return ;
71939   }
71940   {
71941     try {
71942       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
71943     } catch (std::out_of_range& e) {
71944       {
71945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71946       };
71947     } catch (std::exception& e) {
71948       {
71949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71950       };
71951     } catch (...) {
71952       {
71953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71954       };
71955     }
71956   }
71957 }
71958
71959
71960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
71961   Dali::Vector3 *arg1 = 0 ;
71962   PropertyInputContainer *arg2 = 0 ;
71963
71964   arg1 = (Dali::Vector3 *)jarg1;
71965   if (!arg1) {
71966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
71967     return ;
71968   }
71969   arg2 = (PropertyInputContainer *)jarg2;
71970   if (!arg2) {
71971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
71972     return ;
71973   }
71974   {
71975     try {
71976       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
71977     } catch (std::out_of_range& e) {
71978       {
71979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71980       };
71981     } catch (std::exception& e) {
71982       {
71983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71984       };
71985     } catch (...) {
71986       {
71987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71988       };
71989     }
71990   }
71991 }
71992
71993
71994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
71995   void * jresult ;
71996   Dali::Toolkit::ScrollViewEffect *result = 0 ;
71997
71998   {
71999     try {
72000       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
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 = (void *)result;
72016   return jresult;
72017 }
72018
72019
72020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
72021   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
72022
72023   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
72024   {
72025     try {
72026       delete arg1;
72027     } catch (std::out_of_range& e) {
72028       {
72029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72030       };
72031     } catch (std::exception& e) {
72032       {
72033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72034       };
72035     } catch (...) {
72036       {
72037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72038       };
72039     }
72040   }
72041 }
72042
72043
72044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
72045   void * jresult ;
72046   Dali::Path arg1 ;
72047   Dali::Vector3 *arg2 = 0 ;
72048   Dali::Property::Index arg3 ;
72049   Dali::Vector3 *arg4 = 0 ;
72050   unsigned int arg5 ;
72051   Dali::Path *argp1 ;
72052   Dali::Toolkit::ScrollViewPagePathEffect result;
72053
72054   argp1 = (Dali::Path *)jarg1;
72055   if (!argp1) {
72056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
72057     return 0;
72058   }
72059   arg1 = *argp1;
72060   arg2 = (Dali::Vector3 *)jarg2;
72061   if (!arg2) {
72062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72063     return 0;
72064   }
72065   arg3 = (Dali::Property::Index)jarg3;
72066   arg4 = (Dali::Vector3 *)jarg4;
72067   if (!arg4) {
72068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72069     return 0;
72070   }
72071   arg5 = (unsigned int)jarg5;
72072   {
72073     try {
72074       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
72075     } catch (std::out_of_range& e) {
72076       {
72077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72078       };
72079     } catch (std::exception& e) {
72080       {
72081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72082       };
72083     } catch (...) {
72084       {
72085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72086       };
72087     }
72088   }
72089   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
72090   return jresult;
72091 }
72092
72093
72094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
72095   void * jresult ;
72096   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
72097
72098   {
72099     try {
72100       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
72101     } catch (std::out_of_range& e) {
72102       {
72103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72104       };
72105     } catch (std::exception& e) {
72106       {
72107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72108       };
72109     } catch (...) {
72110       {
72111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72112       };
72113     }
72114   }
72115   jresult = (void *)result;
72116   return jresult;
72117 }
72118
72119
72120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
72121   void * jresult ;
72122   Dali::BaseHandle arg1 ;
72123   Dali::BaseHandle *argp1 ;
72124   Dali::Toolkit::ScrollViewPagePathEffect result;
72125
72126   argp1 = (Dali::BaseHandle *)jarg1;
72127   if (!argp1) {
72128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72129     return 0;
72130   }
72131   arg1 = *argp1;
72132   {
72133     try {
72134       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
72135     } catch (std::out_of_range& e) {
72136       {
72137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72138       };
72139     } catch (std::exception& e) {
72140       {
72141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72142       };
72143     } catch (...) {
72144       {
72145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72146       };
72147     }
72148   }
72149   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
72150   return jresult;
72151 }
72152
72153
72154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
72155   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72156   Dali::Actor arg2 ;
72157   unsigned int arg3 ;
72158   Dali::Actor *argp2 ;
72159
72160   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72161   argp2 = (Dali::Actor *)jarg2;
72162   if (!argp2) {
72163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
72164     return ;
72165   }
72166   arg2 = *argp2;
72167   arg3 = (unsigned int)jarg3;
72168   {
72169     try {
72170       (arg1)->ApplyToPage(arg2,arg3);
72171     } catch (std::out_of_range& e) {
72172       {
72173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72174       };
72175     } catch (std::exception& e) {
72176       {
72177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72178       };
72179     } catch (...) {
72180       {
72181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72182       };
72183     }
72184   }
72185 }
72186
72187
72188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
72189   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72190
72191   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72192   {
72193     try {
72194       delete arg1;
72195     } catch (std::out_of_range& e) {
72196       {
72197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72198       };
72199     } catch (std::exception& e) {
72200       {
72201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72202       };
72203     } catch (...) {
72204       {
72205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72206       };
72207     }
72208   }
72209 }
72210
72211
72212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
72213   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72214   Dali::Toolkit::ClampState arg2 ;
72215
72216   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72217   arg2 = (Dali::Toolkit::ClampState)jarg2;
72218   if (arg1) (arg1)->x = arg2;
72219 }
72220
72221
72222 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
72223   int jresult ;
72224   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72225   Dali::Toolkit::ClampState result;
72226
72227   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72228   result = (Dali::Toolkit::ClampState) ((arg1)->x);
72229   jresult = (int)result;
72230   return jresult;
72231 }
72232
72233
72234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
72235   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72236   Dali::Toolkit::ClampState arg2 ;
72237
72238   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72239   arg2 = (Dali::Toolkit::ClampState)jarg2;
72240   if (arg1) (arg1)->y = arg2;
72241 }
72242
72243
72244 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
72245   int jresult ;
72246   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72247   Dali::Toolkit::ClampState result;
72248
72249   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72250   result = (Dali::Toolkit::ClampState) ((arg1)->y);
72251   jresult = (int)result;
72252   return jresult;
72253 }
72254
72255
72256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
72257   void * jresult ;
72258   Dali::Toolkit::ClampState2D *result = 0 ;
72259
72260   {
72261     try {
72262       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
72263     } catch (std::out_of_range& e) {
72264       {
72265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72266       };
72267     } catch (std::exception& e) {
72268       {
72269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72270       };
72271     } catch (...) {
72272       {
72273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72274       };
72275     }
72276   }
72277   jresult = (void *)result;
72278   return jresult;
72279 }
72280
72281
72282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
72283   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72284
72285   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72286   {
72287     try {
72288       delete arg1;
72289     } catch (std::out_of_range& e) {
72290       {
72291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72292       };
72293     } catch (std::exception& e) {
72294       {
72295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72296       };
72297     } catch (...) {
72298       {
72299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72300       };
72301     }
72302   }
72303 }
72304
72305
72306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
72307   void * jresult ;
72308   float arg1 ;
72309   float arg2 ;
72310   bool arg3 ;
72311   Dali::Toolkit::RulerDomain *result = 0 ;
72312
72313   arg1 = (float)jarg1;
72314   arg2 = (float)jarg2;
72315   arg3 = jarg3 ? true : false;
72316   {
72317     try {
72318       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
72319     } catch (std::out_of_range& e) {
72320       {
72321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72322       };
72323     } catch (std::exception& e) {
72324       {
72325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72326       };
72327     } catch (...) {
72328       {
72329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72330       };
72331     }
72332   }
72333   jresult = (void *)result;
72334   return jresult;
72335 }
72336
72337
72338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
72339   void * jresult ;
72340   float arg1 ;
72341   float arg2 ;
72342   Dali::Toolkit::RulerDomain *result = 0 ;
72343
72344   arg1 = (float)jarg1;
72345   arg2 = (float)jarg2;
72346   {
72347     try {
72348       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
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 = (void *)result;
72364   return jresult;
72365 }
72366
72367
72368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
72369   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72370   float arg2 ;
72371
72372   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72373   arg2 = (float)jarg2;
72374   if (arg1) (arg1)->min = arg2;
72375 }
72376
72377
72378 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
72379   float jresult ;
72380   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72381   float result;
72382
72383   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72384   result = (float) ((arg1)->min);
72385   jresult = result;
72386   return jresult;
72387 }
72388
72389
72390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
72391   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72392   float arg2 ;
72393
72394   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72395   arg2 = (float)jarg2;
72396   if (arg1) (arg1)->max = arg2;
72397 }
72398
72399
72400 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
72401   float jresult ;
72402   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72403   float result;
72404
72405   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72406   result = (float) ((arg1)->max);
72407   jresult = result;
72408   return jresult;
72409 }
72410
72411
72412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
72413   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72414   bool arg2 ;
72415
72416   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72417   arg2 = jarg2 ? true : false;
72418   if (arg1) (arg1)->enabled = arg2;
72419 }
72420
72421
72422 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
72423   unsigned int jresult ;
72424   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72425   bool result;
72426
72427   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72428   result = (bool) ((arg1)->enabled);
72429   jresult = result;
72430   return jresult;
72431 }
72432
72433
72434 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
72435   float jresult ;
72436   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72437   float arg2 ;
72438   float arg3 ;
72439   float arg4 ;
72440   float result;
72441
72442   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72443   arg2 = (float)jarg2;
72444   arg3 = (float)jarg3;
72445   arg4 = (float)jarg4;
72446   {
72447     try {
72448       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
72449     } catch (std::out_of_range& e) {
72450       {
72451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72452       };
72453     } catch (std::exception& e) {
72454       {
72455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72456       };
72457     } catch (...) {
72458       {
72459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72460       };
72461     }
72462   }
72463   jresult = result;
72464   return jresult;
72465 }
72466
72467
72468 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
72469   float jresult ;
72470   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72471   float arg2 ;
72472   float arg3 ;
72473   float result;
72474
72475   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72476   arg2 = (float)jarg2;
72477   arg3 = (float)jarg3;
72478   {
72479     try {
72480       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
72481     } catch (std::out_of_range& e) {
72482       {
72483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72484       };
72485     } catch (std::exception& e) {
72486       {
72487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72488       };
72489     } catch (...) {
72490       {
72491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72492       };
72493     }
72494   }
72495   jresult = result;
72496   return jresult;
72497 }
72498
72499
72500 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
72501   float jresult ;
72502   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72503   float arg2 ;
72504   float result;
72505
72506   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72507   arg2 = (float)jarg2;
72508   {
72509     try {
72510       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
72511     } catch (std::out_of_range& e) {
72512       {
72513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72514       };
72515     } catch (std::exception& e) {
72516       {
72517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72518       };
72519     } catch (...) {
72520       {
72521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72522       };
72523     }
72524   }
72525   jresult = result;
72526   return jresult;
72527 }
72528
72529
72530 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
72531   float jresult ;
72532   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72533   float arg2 ;
72534   float arg3 ;
72535   float arg4 ;
72536   Dali::Toolkit::ClampState *arg5 = 0 ;
72537   float result;
72538
72539   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72540   arg2 = (float)jarg2;
72541   arg3 = (float)jarg3;
72542   arg4 = (float)jarg4;
72543   arg5 = (Dali::Toolkit::ClampState *)jarg5;
72544   if (!arg5) {
72545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
72546     return 0;
72547   }
72548   {
72549     try {
72550       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
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_RulerDomain_GetSize(void * jarg1) {
72571   float jresult ;
72572   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72573   float result;
72574
72575   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72576   {
72577     try {
72578       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
72579     } catch (std::out_of_range& e) {
72580       {
72581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72582       };
72583     } catch (std::exception& e) {
72584       {
72585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72586       };
72587     } catch (...) {
72588       {
72589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72590       };
72591     }
72592   }
72593   jresult = result;
72594   return jresult;
72595 }
72596
72597
72598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
72599   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72600
72601   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72602   {
72603     try {
72604       delete arg1;
72605     } catch (std::out_of_range& e) {
72606       {
72607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72608       };
72609     } catch (std::exception& e) {
72610       {
72611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72612       };
72613     } catch (...) {
72614       {
72615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72616       };
72617     }
72618   }
72619 }
72620
72621
72622 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
72623   float jresult ;
72624   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72625   float arg2 ;
72626   float arg3 ;
72627   float result;
72628
72629   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72630   arg2 = (float)jarg2;
72631   arg3 = (float)jarg3;
72632   {
72633     try {
72634       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
72635     } catch (std::out_of_range& e) {
72636       {
72637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72638       };
72639     } catch (std::exception& e) {
72640       {
72641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72642       };
72643     } catch (...) {
72644       {
72645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72646       };
72647     }
72648   }
72649   jresult = result;
72650   return jresult;
72651 }
72652
72653
72654 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
72655   float jresult ;
72656   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72657   float arg2 ;
72658   float result;
72659
72660   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72661   arg2 = (float)jarg2;
72662   {
72663     try {
72664       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
72665     } catch (std::out_of_range& e) {
72666       {
72667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72668       };
72669     } catch (std::exception& e) {
72670       {
72671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72672       };
72673     } catch (...) {
72674       {
72675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72676       };
72677     }
72678   }
72679   jresult = result;
72680   return jresult;
72681 }
72682
72683
72684 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
72685   float jresult ;
72686   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72687   unsigned int arg2 ;
72688   unsigned int *arg3 = 0 ;
72689   bool arg4 ;
72690   float result;
72691
72692   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72693   arg2 = (unsigned int)jarg2;
72694   arg3 = (unsigned int *)jarg3;
72695   arg4 = jarg4 ? true : false;
72696   {
72697     try {
72698       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
72699     } catch (std::out_of_range& e) {
72700       {
72701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72702       };
72703     } catch (std::exception& e) {
72704       {
72705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72706       };
72707     } catch (...) {
72708       {
72709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72710       };
72711     }
72712   }
72713   jresult = result;
72714   return jresult;
72715 }
72716
72717
72718 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
72719   unsigned int jresult ;
72720   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72721   float arg2 ;
72722   bool arg3 ;
72723   unsigned int result;
72724
72725   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72726   arg2 = (float)jarg2;
72727   arg3 = jarg3 ? true : false;
72728   {
72729     try {
72730       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
72731     } catch (std::out_of_range& e) {
72732       {
72733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72734       };
72735     } catch (std::exception& e) {
72736       {
72737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72738       };
72739     } catch (...) {
72740       {
72741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72742       };
72743     }
72744   }
72745   jresult = result;
72746   return jresult;
72747 }
72748
72749
72750 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
72751   unsigned int jresult ;
72752   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72753   unsigned int result;
72754
72755   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72756   {
72757     try {
72758       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
72759     } catch (std::out_of_range& e) {
72760       {
72761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72762       };
72763     } catch (std::exception& e) {
72764       {
72765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72766       };
72767     } catch (...) {
72768       {
72769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72770       };
72771     }
72772   }
72773   jresult = result;
72774   return jresult;
72775 }
72776
72777
72778 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
72779   int jresult ;
72780   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72781   Dali::Toolkit::Ruler::RulerType result;
72782
72783   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72784   {
72785     try {
72786       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
72787     } catch (std::out_of_range& e) {
72788       {
72789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72790       };
72791     } catch (std::exception& e) {
72792       {
72793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72794       };
72795     } catch (...) {
72796       {
72797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72798       };
72799     }
72800   }
72801   jresult = (int)result;
72802   return jresult;
72803 }
72804
72805
72806 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
72807   unsigned int jresult ;
72808   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72809   bool result;
72810
72811   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72812   {
72813     try {
72814       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
72815     } catch (std::out_of_range& e) {
72816       {
72817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72818       };
72819     } catch (std::exception& e) {
72820       {
72821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72822       };
72823     } catch (...) {
72824       {
72825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72826       };
72827     }
72828   }
72829   jresult = result;
72830   return jresult;
72831 }
72832
72833
72834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
72835   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72836
72837   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72838   {
72839     try {
72840       (arg1)->Enable();
72841     } catch (std::out_of_range& e) {
72842       {
72843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72844       };
72845     } catch (std::exception& e) {
72846       {
72847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72848       };
72849     } catch (...) {
72850       {
72851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72852       };
72853     }
72854   }
72855 }
72856
72857
72858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
72859   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72860
72861   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72862   {
72863     try {
72864       (arg1)->Disable();
72865     } catch (std::out_of_range& e) {
72866       {
72867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72868       };
72869     } catch (std::exception& e) {
72870       {
72871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72872       };
72873     } catch (...) {
72874       {
72875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72876       };
72877     }
72878   }
72879 }
72880
72881
72882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
72883   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72884   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
72885   Dali::Toolkit::RulerDomain *argp2 ;
72886
72887   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72888   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
72889   if (!argp2) {
72890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
72891     return ;
72892   }
72893   arg2 = *argp2;
72894   {
72895     try {
72896       (arg1)->SetDomain(arg2);
72897     } catch (std::out_of_range& e) {
72898       {
72899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72900       };
72901     } catch (std::exception& e) {
72902       {
72903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72904       };
72905     } catch (...) {
72906       {
72907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72908       };
72909     }
72910   }
72911 }
72912
72913
72914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
72915   void * jresult ;
72916   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72917   Dali::Toolkit::RulerDomain *result = 0 ;
72918
72919   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72920   {
72921     try {
72922       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
72923     } catch (std::out_of_range& e) {
72924       {
72925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72926       };
72927     } catch (std::exception& e) {
72928       {
72929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72930       };
72931     } catch (...) {
72932       {
72933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72934       };
72935     }
72936   }
72937   jresult = (void *)result;
72938   return jresult;
72939 }
72940
72941
72942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
72943   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72944
72945   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72946   {
72947     try {
72948       (arg1)->DisableDomain();
72949     } catch (std::out_of_range& e) {
72950       {
72951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72952       };
72953     } catch (std::exception& e) {
72954       {
72955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72956       };
72957     } catch (...) {
72958       {
72959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72960       };
72961     }
72962   }
72963 }
72964
72965
72966 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
72967   float jresult ;
72968   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72969   float arg2 ;
72970   float arg3 ;
72971   float arg4 ;
72972   float result;
72973
72974   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72975   arg2 = (float)jarg2;
72976   arg3 = (float)jarg3;
72977   arg4 = (float)jarg4;
72978   {
72979     try {
72980       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
72981     } catch (std::out_of_range& e) {
72982       {
72983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72984       };
72985     } catch (std::exception& e) {
72986       {
72987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72988       };
72989     } catch (...) {
72990       {
72991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72992       };
72993     }
72994   }
72995   jresult = result;
72996   return jresult;
72997 }
72998
72999
73000 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
73001   float jresult ;
73002   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73003   float arg2 ;
73004   float arg3 ;
73005   float result;
73006
73007   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73008   arg2 = (float)jarg2;
73009   arg3 = (float)jarg3;
73010   {
73011     try {
73012       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
73013     } catch (std::out_of_range& e) {
73014       {
73015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73016       };
73017     } catch (std::exception& e) {
73018       {
73019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73020       };
73021     } catch (...) {
73022       {
73023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73024       };
73025     }
73026   }
73027   jresult = result;
73028   return jresult;
73029 }
73030
73031
73032 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
73033   float jresult ;
73034   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73035   float arg2 ;
73036   float result;
73037
73038   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73039   arg2 = (float)jarg2;
73040   {
73041     try {
73042       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
73043     } catch (std::out_of_range& e) {
73044       {
73045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73046       };
73047     } catch (std::exception& e) {
73048       {
73049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73050       };
73051     } catch (...) {
73052       {
73053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73054       };
73055     }
73056   }
73057   jresult = result;
73058   return jresult;
73059 }
73060
73061
73062 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
73063   float jresult ;
73064   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73065   float arg2 ;
73066   float arg3 ;
73067   float arg4 ;
73068   Dali::Toolkit::ClampState *arg5 = 0 ;
73069   float result;
73070
73071   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73072   arg2 = (float)jarg2;
73073   arg3 = (float)jarg3;
73074   arg4 = (float)jarg4;
73075   arg5 = (Dali::Toolkit::ClampState *)jarg5;
73076   if (!arg5) {
73077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73078     return 0;
73079   }
73080   {
73081     try {
73082       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
73083     } catch (std::out_of_range& e) {
73084       {
73085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73086       };
73087     } catch (std::exception& e) {
73088       {
73089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73090       };
73091     } catch (...) {
73092       {
73093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73094       };
73095     }
73096   }
73097   jresult = result;
73098   return jresult;
73099 }
73100
73101
73102 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
73103   float jresult ;
73104   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73105   float arg2 ;
73106   float arg3 ;
73107   float arg4 ;
73108   float arg5 ;
73109   float result;
73110
73111   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73112   arg2 = (float)jarg2;
73113   arg3 = (float)jarg3;
73114   arg4 = (float)jarg4;
73115   arg5 = (float)jarg5;
73116   {
73117     try {
73118       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
73119     } catch (std::out_of_range& e) {
73120       {
73121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73122       };
73123     } catch (std::exception& e) {
73124       {
73125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73126       };
73127     } catch (...) {
73128       {
73129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73130       };
73131     }
73132   }
73133   jresult = result;
73134   return jresult;
73135 }
73136
73137
73138 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
73139   float jresult ;
73140   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73141   float arg2 ;
73142   float arg3 ;
73143   float arg4 ;
73144   float result;
73145
73146   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73147   arg2 = (float)jarg2;
73148   arg3 = (float)jarg3;
73149   arg4 = (float)jarg4;
73150   {
73151     try {
73152       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
73153     } catch (std::out_of_range& e) {
73154       {
73155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73156       };
73157     } catch (std::exception& e) {
73158       {
73159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73160       };
73161     } catch (...) {
73162       {
73163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73164       };
73165     }
73166   }
73167   jresult = result;
73168   return jresult;
73169 }
73170
73171
73172 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
73173   float jresult ;
73174   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73175   float arg2 ;
73176   float arg3 ;
73177   float result;
73178
73179   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73180   arg2 = (float)jarg2;
73181   arg3 = (float)jarg3;
73182   {
73183     try {
73184       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
73185     } catch (std::out_of_range& e) {
73186       {
73187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73188       };
73189     } catch (std::exception& e) {
73190       {
73191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73192       };
73193     } catch (...) {
73194       {
73195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73196       };
73197     }
73198   }
73199   jresult = result;
73200   return jresult;
73201 }
73202
73203
73204 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
73205   float jresult ;
73206   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73207   float arg2 ;
73208   float result;
73209
73210   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73211   arg2 = (float)jarg2;
73212   {
73213     try {
73214       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
73215     } catch (std::out_of_range& e) {
73216       {
73217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73218       };
73219     } catch (std::exception& e) {
73220       {
73221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73222       };
73223     } catch (...) {
73224       {
73225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73226       };
73227     }
73228   }
73229   jresult = result;
73230   return jresult;
73231 }
73232
73233
73234 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
73235   float jresult ;
73236   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73237   float arg2 ;
73238   float arg3 ;
73239   float arg4 ;
73240   float arg5 ;
73241   Dali::Toolkit::ClampState *arg6 = 0 ;
73242   float result;
73243
73244   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73245   arg2 = (float)jarg2;
73246   arg3 = (float)jarg3;
73247   arg4 = (float)jarg4;
73248   arg5 = (float)jarg5;
73249   arg6 = (Dali::Toolkit::ClampState *)jarg6;
73250   if (!arg6) {
73251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73252     return 0;
73253   }
73254   {
73255     try {
73256       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
73257     } catch (std::out_of_range& e) {
73258       {
73259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73260       };
73261     } catch (std::exception& e) {
73262       {
73263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73264       };
73265     } catch (...) {
73266       {
73267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73268       };
73269     }
73270   }
73271   jresult = result;
73272   return jresult;
73273 }
73274
73275
73276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
73277   void * jresult ;
73278   Dali::Toolkit::DefaultRuler *result = 0 ;
73279
73280   {
73281     try {
73282       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
73283     } catch (std::out_of_range& e) {
73284       {
73285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73286       };
73287     } catch (std::exception& e) {
73288       {
73289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73290       };
73291     } catch (...) {
73292       {
73293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73294       };
73295     }
73296   }
73297   jresult = (void *)result;
73298   return jresult;
73299 }
73300
73301
73302 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73303   float jresult ;
73304   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73305   float arg2 ;
73306   float arg3 ;
73307   float result;
73308
73309   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73310   arg2 = (float)jarg2;
73311   arg3 = (float)jarg3;
73312   {
73313     try {
73314       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
73315     } catch (std::out_of_range& e) {
73316       {
73317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73318       };
73319     } catch (std::exception& e) {
73320       {
73321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73322       };
73323     } catch (...) {
73324       {
73325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73326       };
73327     }
73328   }
73329   jresult = result;
73330   return jresult;
73331 }
73332
73333
73334 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73335   float jresult ;
73336   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73337   unsigned int arg2 ;
73338   unsigned int *arg3 = 0 ;
73339   bool arg4 ;
73340   float result;
73341
73342   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73343   arg2 = (unsigned int)jarg2;
73344   arg3 = (unsigned int *)jarg3;
73345   arg4 = jarg4 ? true : false;
73346   {
73347     try {
73348       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73349     } catch (std::out_of_range& e) {
73350       {
73351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73352       };
73353     } catch (std::exception& e) {
73354       {
73355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73356       };
73357     } catch (...) {
73358       {
73359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73360       };
73361     }
73362   }
73363   jresult = result;
73364   return jresult;
73365 }
73366
73367
73368 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73369   unsigned int jresult ;
73370   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73371   float arg2 ;
73372   bool arg3 ;
73373   unsigned int result;
73374
73375   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73376   arg2 = (float)jarg2;
73377   arg3 = jarg3 ? true : false;
73378   {
73379     try {
73380       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
73381     } catch (std::out_of_range& e) {
73382       {
73383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73384       };
73385     } catch (std::exception& e) {
73386       {
73387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73388       };
73389     } catch (...) {
73390       {
73391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73392       };
73393     }
73394   }
73395   jresult = result;
73396   return jresult;
73397 }
73398
73399
73400 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
73401   unsigned int jresult ;
73402   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73403   unsigned int result;
73404
73405   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73406   {
73407     try {
73408       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
73409     } catch (std::out_of_range& e) {
73410       {
73411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73412       };
73413     } catch (std::exception& e) {
73414       {
73415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73416       };
73417     } catch (...) {
73418       {
73419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73420       };
73421     }
73422   }
73423   jresult = result;
73424   return jresult;
73425 }
73426
73427
73428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
73429   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73430
73431   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73432   {
73433     try {
73434       delete arg1;
73435     } catch (std::out_of_range& e) {
73436       {
73437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73438       };
73439     } catch (std::exception& e) {
73440       {
73441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73442       };
73443     } catch (...) {
73444       {
73445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73446       };
73447     }
73448   }
73449 }
73450
73451
73452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
73453   void * jresult ;
73454   float arg1 ;
73455   Dali::Toolkit::FixedRuler *result = 0 ;
73456
73457   arg1 = (float)jarg1;
73458   {
73459     try {
73460       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
73461     } catch (std::out_of_range& e) {
73462       {
73463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73464       };
73465     } catch (std::exception& e) {
73466       {
73467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73468       };
73469     } catch (...) {
73470       {
73471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73472       };
73473     }
73474   }
73475   jresult = (void *)result;
73476   return jresult;
73477 }
73478
73479
73480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
73481   void * jresult ;
73482   Dali::Toolkit::FixedRuler *result = 0 ;
73483
73484   {
73485     try {
73486       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
73487     } catch (std::out_of_range& e) {
73488       {
73489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73490       };
73491     } catch (std::exception& e) {
73492       {
73493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73494       };
73495     } catch (...) {
73496       {
73497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73498       };
73499     }
73500   }
73501   jresult = (void *)result;
73502   return jresult;
73503 }
73504
73505
73506 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73507   float jresult ;
73508   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73509   float arg2 ;
73510   float arg3 ;
73511   float result;
73512
73513   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73514   arg2 = (float)jarg2;
73515   arg3 = (float)jarg3;
73516   {
73517     try {
73518       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
73519     } catch (std::out_of_range& e) {
73520       {
73521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73522       };
73523     } catch (std::exception& e) {
73524       {
73525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73526       };
73527     } catch (...) {
73528       {
73529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73530       };
73531     }
73532   }
73533   jresult = result;
73534   return jresult;
73535 }
73536
73537
73538 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73539   float jresult ;
73540   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73541   unsigned int arg2 ;
73542   unsigned int *arg3 = 0 ;
73543   bool arg4 ;
73544   float result;
73545
73546   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73547   arg2 = (unsigned int)jarg2;
73548   arg3 = (unsigned int *)jarg3;
73549   arg4 = jarg4 ? true : false;
73550   {
73551     try {
73552       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73553     } catch (std::out_of_range& e) {
73554       {
73555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73556       };
73557     } catch (std::exception& e) {
73558       {
73559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73560       };
73561     } catch (...) {
73562       {
73563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73564       };
73565     }
73566   }
73567   jresult = result;
73568   return jresult;
73569 }
73570
73571
73572 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73573   unsigned int jresult ;
73574   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73575   float arg2 ;
73576   bool arg3 ;
73577   unsigned int result;
73578
73579   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73580   arg2 = (float)jarg2;
73581   arg3 = jarg3 ? true : false;
73582   {
73583     try {
73584       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
73585     } catch (std::out_of_range& e) {
73586       {
73587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73588       };
73589     } catch (std::exception& e) {
73590       {
73591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73592       };
73593     } catch (...) {
73594       {
73595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73596       };
73597     }
73598   }
73599   jresult = result;
73600   return jresult;
73601 }
73602
73603
73604 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
73605   unsigned int jresult ;
73606   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73607   unsigned int result;
73608
73609   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73610   {
73611     try {
73612       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
73613     } catch (std::out_of_range& e) {
73614       {
73615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73616       };
73617     } catch (std::exception& e) {
73618       {
73619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73620       };
73621     } catch (...) {
73622       {
73623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73624       };
73625     }
73626   }
73627   jresult = result;
73628   return jresult;
73629 }
73630
73631
73632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
73633   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73634
73635   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73636   {
73637     try {
73638       delete arg1;
73639     } catch (std::out_of_range& e) {
73640       {
73641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73642       };
73643     } catch (std::exception& e) {
73644       {
73645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73646       };
73647     } catch (...) {
73648       {
73649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73650       };
73651     }
73652   }
73653 }
73654
73655
73656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
73657   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73658   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
73659
73660   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73661   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
73662   if (arg1) (arg1)->scale = *arg2;
73663 }
73664
73665
73666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
73667   void * jresult ;
73668   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73669   Dali::Toolkit::ClampState2D *result = 0 ;
73670
73671   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73672   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
73673   jresult = (void *)result;
73674   return jresult;
73675 }
73676
73677
73678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
73679   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73680   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
73681
73682   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73683   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
73684   if (arg1) (arg1)->position = *arg2;
73685 }
73686
73687
73688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
73689   void * jresult ;
73690   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73691   Dali::Toolkit::ClampState2D *result = 0 ;
73692
73693   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73694   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
73695   jresult = (void *)result;
73696   return jresult;
73697 }
73698
73699
73700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
73701   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73702   Dali::Toolkit::ClampState arg2 ;
73703
73704   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73705   arg2 = (Dali::Toolkit::ClampState)jarg2;
73706   if (arg1) (arg1)->rotation = arg2;
73707 }
73708
73709
73710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
73711   int jresult ;
73712   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73713   Dali::Toolkit::ClampState result;
73714
73715   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73716   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
73717   jresult = (int)result;
73718   return jresult;
73719 }
73720
73721
73722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
73723   void * jresult ;
73724   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
73725
73726   {
73727     try {
73728       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
73729     } catch (std::out_of_range& e) {
73730       {
73731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73732       };
73733     } catch (std::exception& e) {
73734       {
73735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73736       };
73737     } catch (...) {
73738       {
73739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73740       };
73741     }
73742   }
73743   jresult = (void *)result;
73744   return jresult;
73745 }
73746
73747
73748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
73749   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73750
73751   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73752   {
73753     try {
73754       delete arg1;
73755     } catch (std::out_of_range& e) {
73756       {
73757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73758       };
73759     } catch (std::exception& e) {
73760       {
73761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73762       };
73763     } catch (...) {
73764       {
73765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73766       };
73767     }
73768   }
73769 }
73770
73771
73772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
73773   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73774   Dali::Toolkit::SnapType arg2 ;
73775
73776   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73777   arg2 = (Dali::Toolkit::SnapType)jarg2;
73778   if (arg1) (arg1)->type = arg2;
73779 }
73780
73781
73782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
73783   int jresult ;
73784   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73785   Dali::Toolkit::SnapType result;
73786
73787   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73788   result = (Dali::Toolkit::SnapType) ((arg1)->type);
73789   jresult = (int)result;
73790   return jresult;
73791 }
73792
73793
73794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
73795   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73796   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
73797
73798   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73799   arg2 = (Dali::Vector2 *)jarg2;
73800   if (arg1) (arg1)->position = *arg2;
73801 }
73802
73803
73804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
73805   void * jresult ;
73806   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73807   Dali::Vector2 *result = 0 ;
73808
73809   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73810   result = (Dali::Vector2 *)& ((arg1)->position);
73811   jresult = (void *)result;
73812   return jresult;
73813 }
73814
73815
73816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
73817   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73818   float arg2 ;
73819
73820   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73821   arg2 = (float)jarg2;
73822   if (arg1) (arg1)->duration = arg2;
73823 }
73824
73825
73826 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
73827   float jresult ;
73828   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73829   float result;
73830
73831   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73832   result = (float) ((arg1)->duration);
73833   jresult = result;
73834   return jresult;
73835 }
73836
73837
73838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
73839   void * jresult ;
73840   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
73841
73842   {
73843     try {
73844       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
73845     } catch (std::out_of_range& e) {
73846       {
73847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73848       };
73849     } catch (std::exception& e) {
73850       {
73851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73852       };
73853     } catch (...) {
73854       {
73855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73856       };
73857     }
73858   }
73859   jresult = (void *)result;
73860   return jresult;
73861 }
73862
73863
73864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
73865   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73866
73867   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73868   {
73869     try {
73870       delete arg1;
73871     } catch (std::out_of_range& e) {
73872       {
73873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73874       };
73875     } catch (std::exception& e) {
73876       {
73877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73878       };
73879     } catch (...) {
73880       {
73881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73882       };
73883     }
73884   }
73885 }
73886
73887
73888 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
73889   int jresult ;
73890   int result;
73891
73892   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
73893   jresult = (int)result;
73894   return jresult;
73895 }
73896
73897
73898 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
73899   int jresult ;
73900   int result;
73901
73902   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
73903   jresult = (int)result;
73904   return jresult;
73905 }
73906
73907
73908 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
73909   int jresult ;
73910   int result;
73911
73912   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
73913   jresult = (int)result;
73914   return jresult;
73915 }
73916
73917
73918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
73919   int jresult ;
73920   int result;
73921
73922   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
73923   jresult = (int)result;
73924   return jresult;
73925 }
73926
73927
73928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
73929   int jresult ;
73930   int result;
73931
73932   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
73933   jresult = (int)result;
73934   return jresult;
73935 }
73936
73937
73938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
73939   int jresult ;
73940   int result;
73941
73942   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
73943   jresult = (int)result;
73944   return jresult;
73945 }
73946
73947
73948 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
73949   int jresult ;
73950   int result;
73951
73952   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
73953   jresult = (int)result;
73954   return jresult;
73955 }
73956
73957
73958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
73959   int jresult ;
73960   int result;
73961
73962   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
73963   jresult = (int)result;
73964   return jresult;
73965 }
73966
73967
73968 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
73969   int jresult ;
73970   int result;
73971
73972   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
73973   jresult = (int)result;
73974   return jresult;
73975 }
73976
73977
73978 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
73979   int jresult ;
73980   int result;
73981
73982   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
73983   jresult = (int)result;
73984   return jresult;
73985 }
73986
73987
73988 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
73989   int jresult ;
73990   int result;
73991
73992   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
73993   jresult = (int)result;
73994   return jresult;
73995 }
73996
73997
73998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
73999   int jresult ;
74000   int result;
74001
74002   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
74003   jresult = (int)result;
74004   return jresult;
74005 }
74006
74007
74008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
74009   int jresult ;
74010   int result;
74011
74012   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
74013   jresult = (int)result;
74014   return jresult;
74015 }
74016
74017
74018 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
74019   int jresult ;
74020   int result;
74021
74022   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
74023   jresult = (int)result;
74024   return jresult;
74025 }
74026
74027
74028 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
74029   int jresult ;
74030   int result;
74031
74032   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
74033   jresult = (int)result;
74034   return jresult;
74035 }
74036
74037
74038 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
74039   int jresult ;
74040   int result;
74041
74042   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
74043   jresult = (int)result;
74044   return jresult;
74045 }
74046
74047
74048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
74049   int jresult ;
74050   int result;
74051
74052   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
74053   jresult = (int)result;
74054   return jresult;
74055 }
74056
74057
74058 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
74059   int jresult ;
74060   int result;
74061
74062   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
74063   jresult = (int)result;
74064   return jresult;
74065 }
74066
74067
74068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
74069   int jresult ;
74070   int result;
74071
74072   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
74073   jresult = (int)result;
74074   return jresult;
74075 }
74076
74077
74078 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
74079   int jresult ;
74080   int result;
74081
74082   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
74083   jresult = (int)result;
74084   return jresult;
74085 }
74086
74087
74088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
74089   int jresult ;
74090   int result;
74091
74092   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
74093   jresult = (int)result;
74094   return jresult;
74095 }
74096
74097
74098 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
74099   int jresult ;
74100   int result;
74101
74102   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
74103   jresult = (int)result;
74104   return jresult;
74105 }
74106
74107
74108 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
74109   int jresult ;
74110   int result;
74111
74112   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
74113   jresult = (int)result;
74114   return jresult;
74115 }
74116
74117
74118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
74119   int jresult ;
74120   int result;
74121
74122   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
74123   jresult = (int)result;
74124   return jresult;
74125 }
74126
74127
74128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
74129   int jresult ;
74130   int result;
74131
74132   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
74133   jresult = (int)result;
74134   return jresult;
74135 }
74136
74137
74138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
74139   void * jresult ;
74140   Dali::Toolkit::ScrollView::Property *result = 0 ;
74141
74142   {
74143     try {
74144       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
74145     } catch (std::out_of_range& e) {
74146       {
74147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74148       };
74149     } catch (std::exception& e) {
74150       {
74151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74152       };
74153     } catch (...) {
74154       {
74155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74156       };
74157     }
74158   }
74159   jresult = (void *)result;
74160   return jresult;
74161 }
74162
74163
74164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
74165   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
74166
74167   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
74168   {
74169     try {
74170       delete arg1;
74171     } catch (std::out_of_range& e) {
74172       {
74173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74174       };
74175     } catch (std::exception& e) {
74176       {
74177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74178       };
74179     } catch (...) {
74180       {
74181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74182       };
74183     }
74184   }
74185 }
74186
74187
74188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
74189   void * jresult ;
74190   Dali::Toolkit::ScrollView *result = 0 ;
74191
74192   {
74193     try {
74194       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
74195     } catch (std::out_of_range& e) {
74196       {
74197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74198       };
74199     } catch (std::exception& e) {
74200       {
74201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74202       };
74203     } catch (...) {
74204       {
74205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74206       };
74207     }
74208   }
74209   jresult = (void *)result;
74210   return jresult;
74211 }
74212
74213
74214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
74215   void * jresult ;
74216   Dali::Toolkit::ScrollView *arg1 = 0 ;
74217   Dali::Toolkit::ScrollView *result = 0 ;
74218
74219   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74220   if (!arg1) {
74221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74222     return 0;
74223   }
74224   {
74225     try {
74226       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
74227     } catch (std::out_of_range& e) {
74228       {
74229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74230       };
74231     } catch (std::exception& e) {
74232       {
74233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74234       };
74235     } catch (...) {
74236       {
74237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74238       };
74239     }
74240   }
74241   jresult = (void *)result;
74242   return jresult;
74243 }
74244
74245
74246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
74247   void * jresult ;
74248   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74249   Dali::Toolkit::ScrollView *arg2 = 0 ;
74250   Dali::Toolkit::ScrollView *result = 0 ;
74251
74252   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74253   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
74254   if (!arg2) {
74255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74256     return 0;
74257   }
74258   {
74259     try {
74260       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
74261     } catch (std::out_of_range& e) {
74262       {
74263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74264       };
74265     } catch (std::exception& e) {
74266       {
74267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74268       };
74269     } catch (...) {
74270       {
74271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74272       };
74273     }
74274   }
74275   jresult = (void *)result;
74276   return jresult;
74277 }
74278
74279
74280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
74281   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74282
74283   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74284   {
74285     try {
74286       delete arg1;
74287     } catch (std::out_of_range& e) {
74288       {
74289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74290       };
74291     } catch (std::exception& e) {
74292       {
74293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74294       };
74295     } catch (...) {
74296       {
74297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74298       };
74299     }
74300   }
74301 }
74302
74303
74304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
74305   void * jresult ;
74306   Dali::Toolkit::ScrollView result;
74307
74308   {
74309     try {
74310       result = Dali::Toolkit::ScrollView::New();
74311     } catch (std::out_of_range& e) {
74312       {
74313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74314       };
74315     } catch (std::exception& e) {
74316       {
74317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74318       };
74319     } catch (...) {
74320       {
74321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74322       };
74323     }
74324   }
74325   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74326   return jresult;
74327 }
74328
74329
74330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
74331   void * jresult ;
74332   Dali::BaseHandle arg1 ;
74333   Dali::BaseHandle *argp1 ;
74334   Dali::Toolkit::ScrollView result;
74335
74336   argp1 = (Dali::BaseHandle *)jarg1;
74337   if (!argp1) {
74338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74339     return 0;
74340   }
74341   arg1 = *argp1;
74342   {
74343     try {
74344       result = Dali::Toolkit::ScrollView::DownCast(arg1);
74345     } catch (std::out_of_range& e) {
74346       {
74347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74348       };
74349     } catch (std::exception& e) {
74350       {
74351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74352       };
74353     } catch (...) {
74354       {
74355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74356       };
74357     }
74358   }
74359   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74360   return jresult;
74361 }
74362
74363
74364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
74365   void * jresult ;
74366   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74367   Dali::AlphaFunction result;
74368
74369   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74370   {
74371     try {
74372       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
74373     } catch (std::out_of_range& e) {
74374       {
74375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74376       };
74377     } catch (std::exception& e) {
74378       {
74379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74380       };
74381     } catch (...) {
74382       {
74383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74384       };
74385     }
74386   }
74387   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
74388   return jresult;
74389 }
74390
74391
74392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
74393   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74394   Dali::AlphaFunction arg2 ;
74395   Dali::AlphaFunction *argp2 ;
74396
74397   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74398   argp2 = (Dali::AlphaFunction *)jarg2;
74399   if (!argp2) {
74400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74401     return ;
74402   }
74403   arg2 = *argp2;
74404   {
74405     try {
74406       (arg1)->SetScrollSnapAlphaFunction(arg2);
74407     } catch (std::out_of_range& e) {
74408       {
74409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74410       };
74411     } catch (std::exception& e) {
74412       {
74413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74414       };
74415     } catch (...) {
74416       {
74417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74418       };
74419     }
74420   }
74421 }
74422
74423
74424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
74425   void * jresult ;
74426   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74427   Dali::AlphaFunction result;
74428
74429   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74430   {
74431     try {
74432       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
74433     } catch (std::out_of_range& e) {
74434       {
74435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74436       };
74437     } catch (std::exception& e) {
74438       {
74439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74440       };
74441     } catch (...) {
74442       {
74443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74444       };
74445     }
74446   }
74447   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
74448   return jresult;
74449 }
74450
74451
74452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
74453   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74454   Dali::AlphaFunction arg2 ;
74455   Dali::AlphaFunction *argp2 ;
74456
74457   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74458   argp2 = (Dali::AlphaFunction *)jarg2;
74459   if (!argp2) {
74460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74461     return ;
74462   }
74463   arg2 = *argp2;
74464   {
74465     try {
74466       (arg1)->SetScrollFlickAlphaFunction(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_GetScrollSnapDuration(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)->GetScrollSnapDuration();
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_SetScrollSnapDuration(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)->SetScrollSnapDuration(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_GetScrollFlickDuration(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)->GetScrollFlickDuration();
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_SetScrollFlickDuration(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)->SetScrollFlickDuration(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_SetRulerX(void * jarg1, void * jarg2) {
74593   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74594   Dali::Toolkit::RulerPtr arg2 ;
74595   Dali::Toolkit::RulerPtr *argp2 ;
74596
74597   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74598   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
74599   if (!argp2) {
74600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
74601     return ;
74602   }
74603   arg2 = *argp2;
74604   {
74605     try {
74606       (arg1)->SetRulerX(arg2);
74607     } catch (std::out_of_range& e) {
74608       {
74609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74610       };
74611     } catch (std::exception& e) {
74612       {
74613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74614       };
74615     } catch (...) {
74616       {
74617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74618       };
74619     }
74620   }
74621 }
74622
74623
74624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
74625   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74626   Dali::Toolkit::RulerPtr arg2 ;
74627   Dali::Toolkit::RulerPtr *argp2 ;
74628
74629   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74630   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
74631   if (!argp2) {
74632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
74633     return ;
74634   }
74635   arg2 = *argp2;
74636   {
74637     try {
74638       (arg1)->SetRulerY(arg2);
74639     } catch (std::out_of_range& e) {
74640       {
74641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74642       };
74643     } catch (std::exception& e) {
74644       {
74645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74646       };
74647     } catch (...) {
74648       {
74649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74650       };
74651     }
74652   }
74653 }
74654
74655
74656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
74657   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74658   bool arg2 ;
74659
74660   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74661   arg2 = jarg2 ? true : false;
74662   {
74663     try {
74664       (arg1)->SetScrollSensitive(arg2);
74665     } catch (std::out_of_range& e) {
74666       {
74667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74668       };
74669     } catch (std::exception& e) {
74670       {
74671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74672       };
74673     } catch (...) {
74674       {
74675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74676       };
74677     }
74678   }
74679 }
74680
74681
74682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
74683   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74684   float arg2 ;
74685   float arg3 ;
74686
74687   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74688   arg2 = (float)jarg2;
74689   arg3 = (float)jarg3;
74690   {
74691     try {
74692       (arg1)->SetMaxOvershoot(arg2,arg3);
74693     } catch (std::out_of_range& e) {
74694       {
74695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74696       };
74697     } catch (std::exception& e) {
74698       {
74699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74700       };
74701     } catch (...) {
74702       {
74703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74704       };
74705     }
74706   }
74707 }
74708
74709
74710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
74711   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74712   Dali::AlphaFunction arg2 ;
74713   Dali::AlphaFunction *argp2 ;
74714
74715   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74716   argp2 = (Dali::AlphaFunction *)jarg2;
74717   if (!argp2) {
74718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74719     return ;
74720   }
74721   arg2 = *argp2;
74722   {
74723     try {
74724       (arg1)->SetSnapOvershootAlphaFunction(arg2);
74725     } catch (std::out_of_range& e) {
74726       {
74727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74728       };
74729     } catch (std::exception& e) {
74730       {
74731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74732       };
74733     } catch (...) {
74734       {
74735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74736       };
74737     }
74738   }
74739 }
74740
74741
74742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
74743   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74744   float arg2 ;
74745
74746   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74747   arg2 = (float)jarg2;
74748   {
74749     try {
74750       (arg1)->SetSnapOvershootDuration(arg2);
74751     } catch (std::out_of_range& e) {
74752       {
74753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74754       };
74755     } catch (std::exception& e) {
74756       {
74757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74758       };
74759     } catch (...) {
74760       {
74761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74762       };
74763     }
74764   }
74765 }
74766
74767
74768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
74769   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74770   bool arg2 ;
74771
74772   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74773   arg2 = jarg2 ? true : false;
74774   {
74775     try {
74776       (arg1)->SetActorAutoSnap(arg2);
74777     } catch (std::out_of_range& e) {
74778       {
74779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74780       };
74781     } catch (std::exception& e) {
74782       {
74783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74784       };
74785     } catch (...) {
74786       {
74787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74788       };
74789     }
74790   }
74791 }
74792
74793
74794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
74795   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74796   bool arg2 ;
74797
74798   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74799   arg2 = jarg2 ? true : false;
74800   {
74801     try {
74802       (arg1)->SetWrapMode(arg2);
74803     } catch (std::out_of_range& e) {
74804       {
74805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74806       };
74807     } catch (std::exception& e) {
74808       {
74809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74810       };
74811     } catch (...) {
74812       {
74813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74814       };
74815     }
74816   }
74817 }
74818
74819
74820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
74821   int jresult ;
74822   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74823   int result;
74824
74825   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74826   {
74827     try {
74828       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
74829     } catch (std::out_of_range& e) {
74830       {
74831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74832       };
74833     } catch (std::exception& e) {
74834       {
74835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74836       };
74837     } catch (...) {
74838       {
74839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74840       };
74841     }
74842   }
74843   jresult = result;
74844   return jresult;
74845 }
74846
74847
74848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
74849   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74850   int arg2 ;
74851
74852   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74853   arg2 = (int)jarg2;
74854   {
74855     try {
74856       (arg1)->SetScrollUpdateDistance(arg2);
74857     } catch (std::out_of_range& e) {
74858       {
74859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74860       };
74861     } catch (std::exception& e) {
74862       {
74863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74864       };
74865     } catch (...) {
74866       {
74867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74868       };
74869     }
74870   }
74871 }
74872
74873
74874 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
74875   unsigned int jresult ;
74876   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74877   bool result;
74878
74879   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74880   {
74881     try {
74882       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
74883     } catch (std::out_of_range& e) {
74884       {
74885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74886       };
74887     } catch (std::exception& e) {
74888       {
74889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74890       };
74891     } catch (...) {
74892       {
74893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74894       };
74895     }
74896   }
74897   jresult = result;
74898   return jresult;
74899 }
74900
74901
74902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
74903   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74904   bool arg2 ;
74905
74906   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74907   arg2 = jarg2 ? true : false;
74908   {
74909     try {
74910       (arg1)->SetAxisAutoLock(arg2);
74911     } catch (std::out_of_range& e) {
74912       {
74913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74914       };
74915     } catch (std::exception& e) {
74916       {
74917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74918       };
74919     } catch (...) {
74920       {
74921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74922       };
74923     }
74924   }
74925 }
74926
74927
74928 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
74929   float jresult ;
74930   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74931   float result;
74932
74933   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74934   {
74935     try {
74936       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
74937     } catch (std::out_of_range& e) {
74938       {
74939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74940       };
74941     } catch (std::exception& e) {
74942       {
74943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74944       };
74945     } catch (...) {
74946       {
74947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74948       };
74949     }
74950   }
74951   jresult = result;
74952   return jresult;
74953 }
74954
74955
74956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
74957   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74958   float arg2 ;
74959
74960   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74961   arg2 = (float)jarg2;
74962   {
74963     try {
74964       (arg1)->SetAxisAutoLockGradient(arg2);
74965     } catch (std::out_of_range& e) {
74966       {
74967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74968       };
74969     } catch (std::exception& e) {
74970       {
74971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74972       };
74973     } catch (...) {
74974       {
74975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74976       };
74977     }
74978   }
74979 }
74980
74981
74982 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
74983   float jresult ;
74984   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74985   float result;
74986
74987   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74988   {
74989     try {
74990       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
74991     } catch (std::out_of_range& e) {
74992       {
74993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74994       };
74995     } catch (std::exception& e) {
74996       {
74997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74998       };
74999     } catch (...) {
75000       {
75001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75002       };
75003     }
75004   }
75005   jresult = result;
75006   return jresult;
75007 }
75008
75009
75010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
75011   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75012   float arg2 ;
75013
75014   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75015   arg2 = (float)jarg2;
75016   {
75017     try {
75018       (arg1)->SetFrictionCoefficient(arg2);
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 float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
75037   float jresult ;
75038   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75039   float result;
75040
75041   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75042   {
75043     try {
75044       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
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_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
75065   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75066   float arg2 ;
75067
75068   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75069   arg2 = (float)jarg2;
75070   {
75071     try {
75072       (arg1)->SetFlickSpeedCoefficient(arg2);
75073     } catch (std::out_of_range& e) {
75074       {
75075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75076       };
75077     } catch (std::exception& e) {
75078       {
75079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75080       };
75081     } catch (...) {
75082       {
75083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75084       };
75085     }
75086   }
75087 }
75088
75089
75090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
75091   void * jresult ;
75092   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75093   Dali::Vector2 result;
75094
75095   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75096   {
75097     try {
75098       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
75099     } catch (std::out_of_range& e) {
75100       {
75101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75102       };
75103     } catch (std::exception& e) {
75104       {
75105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75106       };
75107     } catch (...) {
75108       {
75109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75110       };
75111     }
75112   }
75113   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75114   return jresult;
75115 }
75116
75117
75118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
75119   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75120   Dali::Vector2 *arg2 = 0 ;
75121
75122   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75123   arg2 = (Dali::Vector2 *)jarg2;
75124   if (!arg2) {
75125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75126     return ;
75127   }
75128   {
75129     try {
75130       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
75131     } catch (std::out_of_range& e) {
75132       {
75133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75134       };
75135     } catch (std::exception& e) {
75136       {
75137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75138       };
75139     } catch (...) {
75140       {
75141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75142       };
75143     }
75144   }
75145 }
75146
75147
75148 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
75149   float jresult ;
75150   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75151   float result;
75152
75153   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75154   {
75155     try {
75156       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
75157     } catch (std::out_of_range& e) {
75158       {
75159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75160       };
75161     } catch (std::exception& e) {
75162       {
75163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75164       };
75165     } catch (...) {
75166       {
75167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75168       };
75169     }
75170   }
75171   jresult = result;
75172   return jresult;
75173 }
75174
75175
75176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
75177   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75178   float arg2 ;
75179
75180   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75181   arg2 = (float)jarg2;
75182   {
75183     try {
75184       (arg1)->SetMinimumSpeedForFlick(arg2);
75185     } catch (std::out_of_range& e) {
75186       {
75187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75188       };
75189     } catch (std::exception& e) {
75190       {
75191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75192       };
75193     } catch (...) {
75194       {
75195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75196       };
75197     }
75198   }
75199 }
75200
75201
75202 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
75203   float jresult ;
75204   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75205   float result;
75206
75207   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75208   {
75209     try {
75210       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
75211     } catch (std::out_of_range& e) {
75212       {
75213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75214       };
75215     } catch (std::exception& e) {
75216       {
75217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75218       };
75219     } catch (...) {
75220       {
75221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75222       };
75223     }
75224   }
75225   jresult = result;
75226   return jresult;
75227 }
75228
75229
75230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
75231   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75232   float arg2 ;
75233
75234   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75235   arg2 = (float)jarg2;
75236   {
75237     try {
75238       (arg1)->SetMaxFlickSpeed(arg2);
75239     } catch (std::out_of_range& e) {
75240       {
75241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75242       };
75243     } catch (std::exception& e) {
75244       {
75245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75246       };
75247     } catch (...) {
75248       {
75249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75250       };
75251     }
75252   }
75253 }
75254
75255
75256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
75257   void * jresult ;
75258   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75259   Dali::Vector2 result;
75260
75261   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75262   {
75263     try {
75264       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
75265     } catch (std::out_of_range& e) {
75266       {
75267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75268       };
75269     } catch (std::exception& e) {
75270       {
75271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75272       };
75273     } catch (...) {
75274       {
75275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75276       };
75277     }
75278   }
75279   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75280   return jresult;
75281 }
75282
75283
75284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
75285   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75286   Dali::Vector2 arg2 ;
75287   Dali::Vector2 *argp2 ;
75288
75289   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75290   argp2 = (Dali::Vector2 *)jarg2;
75291   if (!argp2) {
75292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
75293     return ;
75294   }
75295   arg2 = *argp2;
75296   {
75297     try {
75298       (arg1)->SetWheelScrollDistanceStep(arg2);
75299     } catch (std::out_of_range& e) {
75300       {
75301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75302       };
75303     } catch (std::exception& e) {
75304       {
75305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75306       };
75307     } catch (...) {
75308       {
75309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75310       };
75311     }
75312   }
75313 }
75314
75315
75316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
75317   void * jresult ;
75318   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75319   Dali::Vector2 result;
75320
75321   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75322   {
75323     try {
75324       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
75325     } catch (std::out_of_range& e) {
75326       {
75327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75328       };
75329     } catch (std::exception& e) {
75330       {
75331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75332       };
75333     } catch (...) {
75334       {
75335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75336       };
75337     }
75338   }
75339   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75340   return jresult;
75341 }
75342
75343
75344 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
75345   unsigned int jresult ;
75346   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75347   unsigned int result;
75348
75349   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75350   {
75351     try {
75352       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
75353     } catch (std::out_of_range& e) {
75354       {
75355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75356       };
75357     } catch (std::exception& e) {
75358       {
75359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75360       };
75361     } catch (...) {
75362       {
75363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75364       };
75365     }
75366   }
75367   jresult = result;
75368   return jresult;
75369 }
75370
75371
75372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
75373   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75374   Dali::Vector2 *arg2 = 0 ;
75375
75376   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75377   arg2 = (Dali::Vector2 *)jarg2;
75378   if (!arg2) {
75379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75380     return ;
75381   }
75382   {
75383     try {
75384       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
75385     } catch (std::out_of_range& e) {
75386       {
75387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75388       };
75389     } catch (std::exception& e) {
75390       {
75391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75392       };
75393     } catch (...) {
75394       {
75395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75396       };
75397     }
75398   }
75399 }
75400
75401
75402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
75403   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75404   Dali::Vector2 *arg2 = 0 ;
75405   float arg3 ;
75406
75407   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75408   arg2 = (Dali::Vector2 *)jarg2;
75409   if (!arg2) {
75410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75411     return ;
75412   }
75413   arg3 = (float)jarg3;
75414   {
75415     try {
75416       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
75417     } catch (std::out_of_range& e) {
75418       {
75419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75420       };
75421     } catch (std::exception& e) {
75422       {
75423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75424       };
75425     } catch (...) {
75426       {
75427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75428       };
75429     }
75430   }
75431 }
75432
75433
75434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
75435   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75436   Dali::Vector2 *arg2 = 0 ;
75437   float arg3 ;
75438   Dali::AlphaFunction arg4 ;
75439   Dali::AlphaFunction *argp4 ;
75440
75441   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75442   arg2 = (Dali::Vector2 *)jarg2;
75443   if (!arg2) {
75444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75445     return ;
75446   }
75447   arg3 = (float)jarg3;
75448   argp4 = (Dali::AlphaFunction *)jarg4;
75449   if (!argp4) {
75450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75451     return ;
75452   }
75453   arg4 = *argp4;
75454   {
75455     try {
75456       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
75457     } catch (std::out_of_range& e) {
75458       {
75459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75460       };
75461     } catch (std::exception& e) {
75462       {
75463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75464       };
75465     } catch (...) {
75466       {
75467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75468       };
75469     }
75470   }
75471 }
75472
75473
75474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
75475   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75476   Dali::Vector2 *arg2 = 0 ;
75477   float arg3 ;
75478   Dali::Toolkit::DirectionBias arg4 ;
75479   Dali::Toolkit::DirectionBias arg5 ;
75480
75481   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75482   arg2 = (Dali::Vector2 *)jarg2;
75483   if (!arg2) {
75484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75485     return ;
75486   }
75487   arg3 = (float)jarg3;
75488   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
75489   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
75490   {
75491     try {
75492       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
75493     } catch (std::out_of_range& e) {
75494       {
75495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75496       };
75497     } catch (std::exception& e) {
75498       {
75499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75500       };
75501     } catch (...) {
75502       {
75503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75504       };
75505     }
75506   }
75507 }
75508
75509
75510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
75511   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75512   Dali::Vector2 *arg2 = 0 ;
75513   float arg3 ;
75514   Dali::AlphaFunction arg4 ;
75515   Dali::Toolkit::DirectionBias arg5 ;
75516   Dali::Toolkit::DirectionBias arg6 ;
75517   Dali::AlphaFunction *argp4 ;
75518
75519   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75520   arg2 = (Dali::Vector2 *)jarg2;
75521   if (!arg2) {
75522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75523     return ;
75524   }
75525   arg3 = (float)jarg3;
75526   argp4 = (Dali::AlphaFunction *)jarg4;
75527   if (!argp4) {
75528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75529     return ;
75530   }
75531   arg4 = *argp4;
75532   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
75533   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
75534   {
75535     try {
75536       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
75537     } catch (std::out_of_range& e) {
75538       {
75539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75540       };
75541     } catch (std::exception& e) {
75542       {
75543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75544       };
75545     } catch (...) {
75546       {
75547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75548       };
75549     }
75550   }
75551 }
75552
75553
75554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
75555   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75556   unsigned int arg2 ;
75557
75558   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75559   arg2 = (unsigned int)jarg2;
75560   {
75561     try {
75562       (arg1)->ScrollTo(arg2);
75563     } catch (std::out_of_range& e) {
75564       {
75565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75566       };
75567     } catch (std::exception& e) {
75568       {
75569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75570       };
75571     } catch (...) {
75572       {
75573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75574       };
75575     }
75576   }
75577 }
75578
75579
75580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
75581   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75582   unsigned int arg2 ;
75583   float arg3 ;
75584
75585   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75586   arg2 = (unsigned int)jarg2;
75587   arg3 = (float)jarg3;
75588   {
75589     try {
75590       (arg1)->ScrollTo(arg2,arg3);
75591     } catch (std::out_of_range& e) {
75592       {
75593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75594       };
75595     } catch (std::exception& e) {
75596       {
75597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75598       };
75599     } catch (...) {
75600       {
75601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75602       };
75603     }
75604   }
75605 }
75606
75607
75608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
75609   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75610   unsigned int arg2 ;
75611   float arg3 ;
75612   Dali::Toolkit::DirectionBias arg4 ;
75613
75614   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75615   arg2 = (unsigned int)jarg2;
75616   arg3 = (float)jarg3;
75617   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
75618   {
75619     try {
75620       (arg1)->ScrollTo(arg2,arg3,arg4);
75621     } catch (std::out_of_range& e) {
75622       {
75623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75624       };
75625     } catch (std::exception& e) {
75626       {
75627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75628       };
75629     } catch (...) {
75630       {
75631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75632       };
75633     }
75634   }
75635 }
75636
75637
75638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
75639   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75640   Dali::Actor *arg2 = 0 ;
75641
75642   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75643   arg2 = (Dali::Actor *)jarg2;
75644   if (!arg2) {
75645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75646     return ;
75647   }
75648   {
75649     try {
75650       (arg1)->ScrollTo(*arg2);
75651     } catch (std::out_of_range& e) {
75652       {
75653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75654       };
75655     } catch (std::exception& e) {
75656       {
75657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75658       };
75659     } catch (...) {
75660       {
75661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75662       };
75663     }
75664   }
75665 }
75666
75667
75668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
75669   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75670   Dali::Actor *arg2 = 0 ;
75671   float arg3 ;
75672
75673   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75674   arg2 = (Dali::Actor *)jarg2;
75675   if (!arg2) {
75676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75677     return ;
75678   }
75679   arg3 = (float)jarg3;
75680   {
75681     try {
75682       (arg1)->ScrollTo(*arg2,arg3);
75683     } catch (std::out_of_range& e) {
75684       {
75685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75686       };
75687     } catch (std::exception& e) {
75688       {
75689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75690       };
75691     } catch (...) {
75692       {
75693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75694       };
75695     }
75696   }
75697 }
75698
75699
75700 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
75701   unsigned int jresult ;
75702   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75703   bool result;
75704
75705   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75706   {
75707     try {
75708       result = (bool)(arg1)->ScrollToSnapPoint();
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 = result;
75724   return jresult;
75725 }
75726
75727
75728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
75729   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75730   Dali::Constraint arg2 ;
75731   Dali::Constraint *argp2 ;
75732
75733   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75734   argp2 = (Dali::Constraint *)jarg2;
75735   if (!argp2) {
75736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
75737     return ;
75738   }
75739   arg2 = *argp2;
75740   {
75741     try {
75742       (arg1)->ApplyConstraintToChildren(arg2);
75743     } catch (std::out_of_range& e) {
75744       {
75745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75746       };
75747     } catch (std::exception& e) {
75748       {
75749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75750       };
75751     } catch (...) {
75752       {
75753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75754       };
75755     }
75756   }
75757 }
75758
75759
75760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
75761   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75762
75763   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75764   {
75765     try {
75766       (arg1)->RemoveConstraintsFromChildren();
75767     } catch (std::out_of_range& e) {
75768       {
75769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75770       };
75771     } catch (std::exception& e) {
75772       {
75773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75774       };
75775     } catch (...) {
75776       {
75777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75778       };
75779     }
75780   }
75781 }
75782
75783
75784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
75785   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75786   Dali::Toolkit::ScrollViewEffect arg2 ;
75787   Dali::Toolkit::ScrollViewEffect *argp2 ;
75788
75789   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75790   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
75791   if (!argp2) {
75792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
75793     return ;
75794   }
75795   arg2 = *argp2;
75796   {
75797     try {
75798       (arg1)->ApplyEffect(arg2);
75799     } catch (std::out_of_range& e) {
75800       {
75801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75802       };
75803     } catch (std::exception& e) {
75804       {
75805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75806       };
75807     } catch (...) {
75808       {
75809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75810       };
75811     }
75812   }
75813 }
75814
75815
75816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
75817   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75818   Dali::Toolkit::ScrollViewEffect arg2 ;
75819   Dali::Toolkit::ScrollViewEffect *argp2 ;
75820
75821   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75822   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
75823   if (!argp2) {
75824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
75825     return ;
75826   }
75827   arg2 = *argp2;
75828   {
75829     try {
75830       (arg1)->RemoveEffect(arg2);
75831     } catch (std::out_of_range& e) {
75832       {
75833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75834       };
75835     } catch (std::exception& e) {
75836       {
75837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75838       };
75839     } catch (...) {
75840       {
75841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75842       };
75843     }
75844   }
75845 }
75846
75847
75848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
75849   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75850
75851   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75852   {
75853     try {
75854       (arg1)->RemoveAllEffects();
75855     } catch (std::out_of_range& e) {
75856       {
75857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75858       };
75859     } catch (std::exception& e) {
75860       {
75861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75862       };
75863     } catch (...) {
75864       {
75865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75866       };
75867     }
75868   }
75869 }
75870
75871
75872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
75873   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75874   Dali::Actor arg2 ;
75875   Dali::Actor *argp2 ;
75876
75877   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75878   argp2 = (Dali::Actor *)jarg2;
75879   if (!argp2) {
75880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75881     return ;
75882   }
75883   arg2 = *argp2;
75884   {
75885     try {
75886       (arg1)->BindActor(arg2);
75887     } catch (std::out_of_range& e) {
75888       {
75889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75890       };
75891     } catch (std::exception& e) {
75892       {
75893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75894       };
75895     } catch (...) {
75896       {
75897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75898       };
75899     }
75900   }
75901 }
75902
75903
75904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
75905   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75906   Dali::Actor arg2 ;
75907   Dali::Actor *argp2 ;
75908
75909   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75910   argp2 = (Dali::Actor *)jarg2;
75911   if (!argp2) {
75912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75913     return ;
75914   }
75915   arg2 = *argp2;
75916   {
75917     try {
75918       (arg1)->UnbindActor(arg2);
75919     } catch (std::out_of_range& e) {
75920       {
75921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75922       };
75923     } catch (std::exception& e) {
75924       {
75925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75926       };
75927     } catch (...) {
75928       {
75929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75930       };
75931     }
75932   }
75933 }
75934
75935
75936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
75937   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75938   Dali::Radian arg2 ;
75939   Dali::Radian arg3 ;
75940   Dali::Radian *argp2 ;
75941   Dali::Radian *argp3 ;
75942
75943   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75944   argp2 = (Dali::Radian *)jarg2;
75945   if (!argp2) {
75946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
75947     return ;
75948   }
75949   arg2 = *argp2;
75950   argp3 = (Dali::Radian *)jarg3;
75951   if (!argp3) {
75952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
75953     return ;
75954   }
75955   arg3 = *argp3;
75956   {
75957     try {
75958       (arg1)->SetScrollingDirection(arg2,arg3);
75959     } catch (std::out_of_range& e) {
75960       {
75961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75962       };
75963     } catch (std::exception& e) {
75964       {
75965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75966       };
75967     } catch (...) {
75968       {
75969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75970       };
75971     }
75972   }
75973 }
75974
75975
75976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
75977   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75978   Dali::Radian arg2 ;
75979   Dali::Radian *argp2 ;
75980
75981   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75982   argp2 = (Dali::Radian *)jarg2;
75983   if (!argp2) {
75984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
75985     return ;
75986   }
75987   arg2 = *argp2;
75988   {
75989     try {
75990       (arg1)->SetScrollingDirection(arg2);
75991     } catch (std::out_of_range& e) {
75992       {
75993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75994       };
75995     } catch (std::exception& e) {
75996       {
75997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75998       };
75999     } catch (...) {
76000       {
76001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76002       };
76003     }
76004   }
76005 }
76006
76007
76008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
76009   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76010   Dali::Radian arg2 ;
76011   Dali::Radian *argp2 ;
76012
76013   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76014   argp2 = (Dali::Radian *)jarg2;
76015   if (!argp2) {
76016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76017     return ;
76018   }
76019   arg2 = *argp2;
76020   {
76021     try {
76022       (arg1)->RemoveScrollingDirection(arg2);
76023     } catch (std::out_of_range& e) {
76024       {
76025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76026       };
76027     } catch (std::exception& e) {
76028       {
76029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76030       };
76031     } catch (...) {
76032       {
76033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76034       };
76035     }
76036   }
76037 }
76038
76039
76040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
76041   void * jresult ;
76042   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76043   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
76044
76045   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76046   {
76047     try {
76048       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
76049     } catch (std::out_of_range& e) {
76050       {
76051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76052       };
76053     } catch (std::exception& e) {
76054       {
76055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76056       };
76057     } catch (...) {
76058       {
76059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76060       };
76061     }
76062   }
76063   jresult = (void *)result;
76064   return jresult;
76065 }
76066
76067
76068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
76069   int jresult ;
76070   int result;
76071
76072   result = (int)Dali::Toolkit::TableView::Property::ROWS;
76073   jresult = (int)result;
76074   return jresult;
76075 }
76076
76077
76078 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
76079   int jresult ;
76080   int result;
76081
76082   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
76083   jresult = (int)result;
76084   return jresult;
76085 }
76086
76087
76088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
76089   int jresult ;
76090   int result;
76091
76092   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
76093   jresult = (int)result;
76094   return jresult;
76095 }
76096
76097
76098 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
76099   int jresult ;
76100   int result;
76101
76102   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
76103   jresult = (int)result;
76104   return jresult;
76105 }
76106
76107
76108 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
76109   int jresult ;
76110   int result;
76111
76112   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
76113   jresult = (int)result;
76114   return jresult;
76115 }
76116
76117
76118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
76119   void * jresult ;
76120   Dali::Toolkit::TableView::Property *result = 0 ;
76121
76122   {
76123     try {
76124       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
76125     } catch (std::out_of_range& e) {
76126       {
76127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76128       };
76129     } catch (std::exception& e) {
76130       {
76131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76132       };
76133     } catch (...) {
76134       {
76135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76136       };
76137     }
76138   }
76139   jresult = (void *)result;
76140   return jresult;
76141 }
76142
76143
76144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
76145   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
76146
76147   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
76148   {
76149     try {
76150       delete arg1;
76151     } catch (std::out_of_range& e) {
76152       {
76153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76154       };
76155     } catch (std::exception& e) {
76156       {
76157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76158       };
76159     } catch (...) {
76160       {
76161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76162       };
76163     }
76164   }
76165 }
76166
76167
76168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
76169   int jresult ;
76170   int result;
76171
76172   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
76173   jresult = (int)result;
76174   return jresult;
76175 }
76176
76177
76178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
76179   int jresult ;
76180   int result;
76181
76182   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
76183   jresult = (int)result;
76184   return jresult;
76185 }
76186
76187
76188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
76189   int jresult ;
76190   int result;
76191
76192   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
76193   jresult = (int)result;
76194   return jresult;
76195 }
76196
76197
76198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
76199   int jresult ;
76200   int result;
76201
76202   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
76203   jresult = (int)result;
76204   return jresult;
76205 }
76206
76207
76208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
76209   int jresult ;
76210   int result;
76211
76212   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
76213   jresult = (int)result;
76214   return jresult;
76215 }
76216
76217
76218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
76219   void * jresult ;
76220   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
76221
76222   {
76223     try {
76224       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
76225     } catch (std::out_of_range& e) {
76226       {
76227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76228       };
76229     } catch (std::exception& e) {
76230       {
76231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76232       };
76233     } catch (...) {
76234       {
76235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76236       };
76237     }
76238   }
76239   jresult = (void *)result;
76240   return jresult;
76241 }
76242
76243
76244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
76245   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
76246
76247   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
76248   {
76249     try {
76250       delete arg1;
76251     } catch (std::out_of_range& e) {
76252       {
76253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76254       };
76255     } catch (std::exception& e) {
76256       {
76257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76258       };
76259     } catch (...) {
76260       {
76261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76262       };
76263     }
76264   }
76265 }
76266
76267
76268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
76269   void * jresult ;
76270   unsigned int arg1 ;
76271   unsigned int arg2 ;
76272   unsigned int arg3 ;
76273   unsigned int arg4 ;
76274   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76275
76276   arg1 = (unsigned int)jarg1;
76277   arg2 = (unsigned int)jarg2;
76278   arg3 = (unsigned int)jarg3;
76279   arg4 = (unsigned int)jarg4;
76280   {
76281     try {
76282       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
76283     } catch (std::out_of_range& e) {
76284       {
76285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76286       };
76287     } catch (std::exception& e) {
76288       {
76289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76290       };
76291     } catch (...) {
76292       {
76293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76294       };
76295     }
76296   }
76297   jresult = (void *)result;
76298   return jresult;
76299 }
76300
76301
76302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
76303   void * jresult ;
76304   unsigned int arg1 ;
76305   unsigned int arg2 ;
76306   unsigned int arg3 ;
76307   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76308
76309   arg1 = (unsigned int)jarg1;
76310   arg2 = (unsigned int)jarg2;
76311   arg3 = (unsigned int)jarg3;
76312   {
76313     try {
76314       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
76315     } catch (std::out_of_range& e) {
76316       {
76317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76318       };
76319     } catch (std::exception& e) {
76320       {
76321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76322       };
76323     } catch (...) {
76324       {
76325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76326       };
76327     }
76328   }
76329   jresult = (void *)result;
76330   return jresult;
76331 }
76332
76333
76334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
76335   void * jresult ;
76336   unsigned int arg1 ;
76337   unsigned int arg2 ;
76338   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76339
76340   arg1 = (unsigned int)jarg1;
76341   arg2 = (unsigned int)jarg2;
76342   {
76343     try {
76344       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
76345     } catch (std::out_of_range& e) {
76346       {
76347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76348       };
76349     } catch (std::exception& e) {
76350       {
76351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76352       };
76353     } catch (...) {
76354       {
76355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76356       };
76357     }
76358   }
76359   jresult = (void *)result;
76360   return jresult;
76361 }
76362
76363
76364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
76365   void * jresult ;
76366   unsigned int arg1 ;
76367   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76368
76369   arg1 = (unsigned int)jarg1;
76370   {
76371     try {
76372       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
76373     } catch (std::out_of_range& e) {
76374       {
76375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76376       };
76377     } catch (std::exception& e) {
76378       {
76379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76380       };
76381     } catch (...) {
76382       {
76383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76384       };
76385     }
76386   }
76387   jresult = (void *)result;
76388   return jresult;
76389 }
76390
76391
76392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
76393   void * jresult ;
76394   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76395
76396   {
76397     try {
76398       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
76399     } catch (std::out_of_range& e) {
76400       {
76401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76402       };
76403     } catch (std::exception& e) {
76404       {
76405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76406       };
76407     } catch (...) {
76408       {
76409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76410       };
76411     }
76412   }
76413   jresult = (void *)result;
76414   return jresult;
76415 }
76416
76417
76418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
76419   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76420   unsigned int arg2 ;
76421
76422   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76423   arg2 = (unsigned int)jarg2;
76424   if (arg1) (arg1)->rowIndex = arg2;
76425 }
76426
76427
76428 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
76429   unsigned int jresult ;
76430   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76431   unsigned int result;
76432
76433   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76434   result = (unsigned int) ((arg1)->rowIndex);
76435   jresult = result;
76436   return jresult;
76437 }
76438
76439
76440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
76441   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76442   unsigned int arg2 ;
76443
76444   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76445   arg2 = (unsigned int)jarg2;
76446   if (arg1) (arg1)->columnIndex = arg2;
76447 }
76448
76449
76450 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
76451   unsigned int jresult ;
76452   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76453   unsigned int result;
76454
76455   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76456   result = (unsigned int) ((arg1)->columnIndex);
76457   jresult = result;
76458   return jresult;
76459 }
76460
76461
76462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
76463   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76464   unsigned int arg2 ;
76465
76466   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76467   arg2 = (unsigned int)jarg2;
76468   if (arg1) (arg1)->rowSpan = arg2;
76469 }
76470
76471
76472 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
76473   unsigned int jresult ;
76474   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76475   unsigned int result;
76476
76477   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76478   result = (unsigned int) ((arg1)->rowSpan);
76479   jresult = result;
76480   return jresult;
76481 }
76482
76483
76484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
76485   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76486   unsigned int arg2 ;
76487
76488   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76489   arg2 = (unsigned int)jarg2;
76490   if (arg1) (arg1)->columnSpan = arg2;
76491 }
76492
76493
76494 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
76495   unsigned int jresult ;
76496   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76497   unsigned int result;
76498
76499   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76500   result = (unsigned int) ((arg1)->columnSpan);
76501   jresult = result;
76502   return jresult;
76503 }
76504
76505
76506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
76507   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76508
76509   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76510   {
76511     try {
76512       delete arg1;
76513     } catch (std::out_of_range& e) {
76514       {
76515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76516       };
76517     } catch (std::exception& e) {
76518       {
76519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76520       };
76521     } catch (...) {
76522       {
76523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76524       };
76525     }
76526   }
76527 }
76528
76529
76530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
76531   void * jresult ;
76532   Dali::Toolkit::TableView *result = 0 ;
76533
76534   {
76535     try {
76536       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
76537     } catch (std::out_of_range& e) {
76538       {
76539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76540       };
76541     } catch (std::exception& e) {
76542       {
76543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76544       };
76545     } catch (...) {
76546       {
76547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76548       };
76549     }
76550   }
76551   jresult = (void *)result;
76552   return jresult;
76553 }
76554
76555
76556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
76557   void * jresult ;
76558   Dali::Toolkit::TableView *arg1 = 0 ;
76559   Dali::Toolkit::TableView *result = 0 ;
76560
76561   arg1 = (Dali::Toolkit::TableView *)jarg1;
76562   if (!arg1) {
76563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
76564     return 0;
76565   }
76566   {
76567     try {
76568       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
76569     } catch (std::out_of_range& e) {
76570       {
76571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76572       };
76573     } catch (std::exception& e) {
76574       {
76575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76576       };
76577     } catch (...) {
76578       {
76579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76580       };
76581     }
76582   }
76583   jresult = (void *)result;
76584   return jresult;
76585 }
76586
76587
76588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
76589   void * jresult ;
76590   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76591   Dali::Toolkit::TableView *arg2 = 0 ;
76592   Dali::Toolkit::TableView *result = 0 ;
76593
76594   arg1 = (Dali::Toolkit::TableView *)jarg1;
76595   arg2 = (Dali::Toolkit::TableView *)jarg2;
76596   if (!arg2) {
76597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
76598     return 0;
76599   }
76600   {
76601     try {
76602       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
76603     } catch (std::out_of_range& e) {
76604       {
76605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76606       };
76607     } catch (std::exception& e) {
76608       {
76609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76610       };
76611     } catch (...) {
76612       {
76613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76614       };
76615     }
76616   }
76617   jresult = (void *)result;
76618   return jresult;
76619 }
76620
76621
76622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
76623   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76624
76625   arg1 = (Dali::Toolkit::TableView *)jarg1;
76626   {
76627     try {
76628       delete arg1;
76629     } catch (std::out_of_range& e) {
76630       {
76631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76632       };
76633     } catch (std::exception& e) {
76634       {
76635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76636       };
76637     } catch (...) {
76638       {
76639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76640       };
76641     }
76642   }
76643 }
76644
76645
76646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
76647   void * jresult ;
76648   unsigned int arg1 ;
76649   unsigned int arg2 ;
76650   Dali::Toolkit::TableView result;
76651
76652   arg1 = (unsigned int)jarg1;
76653   arg2 = (unsigned int)jarg2;
76654   {
76655     try {
76656       result = Dali::Toolkit::TableView::New(arg1,arg2);
76657     } catch (std::out_of_range& e) {
76658       {
76659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76660       };
76661     } catch (std::exception& e) {
76662       {
76663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76664       };
76665     } catch (...) {
76666       {
76667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76668       };
76669     }
76670   }
76671   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
76672   return jresult;
76673 }
76674
76675
76676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
76677   void * jresult ;
76678   Dali::BaseHandle arg1 ;
76679   Dali::BaseHandle *argp1 ;
76680   Dali::Toolkit::TableView result;
76681
76682   argp1 = (Dali::BaseHandle *)jarg1;
76683   if (!argp1) {
76684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76685     return 0;
76686   }
76687   arg1 = *argp1;
76688   {
76689     try {
76690       result = Dali::Toolkit::TableView::DownCast(arg1);
76691     } catch (std::out_of_range& e) {
76692       {
76693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76694       };
76695     } catch (std::exception& e) {
76696       {
76697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76698       };
76699     } catch (...) {
76700       {
76701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76702       };
76703     }
76704   }
76705   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
76706   return jresult;
76707 }
76708
76709
76710 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
76711   unsigned int jresult ;
76712   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76713   Dali::Actor arg2 ;
76714   Dali::Toolkit::TableView::CellPosition arg3 ;
76715   Dali::Actor *argp2 ;
76716   Dali::Toolkit::TableView::CellPosition *argp3 ;
76717   bool result;
76718
76719   arg1 = (Dali::Toolkit::TableView *)jarg1;
76720   argp2 = (Dali::Actor *)jarg2;
76721   if (!argp2) {
76722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76723     return 0;
76724   }
76725   arg2 = *argp2;
76726   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
76727   if (!argp3) {
76728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76729     return 0;
76730   }
76731   arg3 = *argp3;
76732   {
76733     try {
76734       result = (bool)(arg1)->AddChild(arg2,arg3);
76735     } catch (std::out_of_range& e) {
76736       {
76737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76738       };
76739     } catch (std::exception& e) {
76740       {
76741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76742       };
76743     } catch (...) {
76744       {
76745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76746       };
76747     }
76748   }
76749   jresult = result;
76750   return jresult;
76751 }
76752
76753
76754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
76755   void * jresult ;
76756   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76757   Dali::Toolkit::TableView::CellPosition arg2 ;
76758   Dali::Toolkit::TableView::CellPosition *argp2 ;
76759   Dali::Actor result;
76760
76761   arg1 = (Dali::Toolkit::TableView *)jarg1;
76762   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
76763   if (!argp2) {
76764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76765     return 0;
76766   }
76767   arg2 = *argp2;
76768   {
76769     try {
76770       result = (arg1)->GetChildAt(arg2);
76771     } catch (std::out_of_range& e) {
76772       {
76773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76774       };
76775     } catch (std::exception& e) {
76776       {
76777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76778       };
76779     } catch (...) {
76780       {
76781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76782       };
76783     }
76784   }
76785   jresult = new Dali::Actor((const Dali::Actor &)result);
76786   return jresult;
76787 }
76788
76789
76790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
76791   void * jresult ;
76792   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76793   Dali::Toolkit::TableView::CellPosition arg2 ;
76794   Dali::Toolkit::TableView::CellPosition *argp2 ;
76795   Dali::Actor result;
76796
76797   arg1 = (Dali::Toolkit::TableView *)jarg1;
76798   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
76799   if (!argp2) {
76800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76801     return 0;
76802   }
76803   arg2 = *argp2;
76804   {
76805     try {
76806       result = (arg1)->RemoveChildAt(arg2);
76807     } catch (std::out_of_range& e) {
76808       {
76809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76810       };
76811     } catch (std::exception& e) {
76812       {
76813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76814       };
76815     } catch (...) {
76816       {
76817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76818       };
76819     }
76820   }
76821   jresult = new Dali::Actor((const Dali::Actor &)result);
76822   return jresult;
76823 }
76824
76825
76826 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
76827   unsigned int jresult ;
76828   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76829   Dali::Actor arg2 ;
76830   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
76831   Dali::Actor *argp2 ;
76832   bool result;
76833
76834   arg1 = (Dali::Toolkit::TableView *)jarg1;
76835   argp2 = (Dali::Actor *)jarg2;
76836   if (!argp2) {
76837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76838     return 0;
76839   }
76840   arg2 = *argp2;
76841   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
76842   if (!arg3) {
76843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
76844     return 0;
76845   }
76846   {
76847     try {
76848       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
76849     } catch (std::out_of_range& e) {
76850       {
76851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76852       };
76853     } catch (std::exception& e) {
76854       {
76855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76856       };
76857     } catch (...) {
76858       {
76859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76860       };
76861     }
76862   }
76863   jresult = result;
76864   return jresult;
76865 }
76866
76867
76868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
76869   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76870   unsigned int arg2 ;
76871
76872   arg1 = (Dali::Toolkit::TableView *)jarg1;
76873   arg2 = (unsigned int)jarg2;
76874   {
76875     try {
76876       (arg1)->InsertRow(arg2);
76877     } catch (std::out_of_range& e) {
76878       {
76879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76880       };
76881     } catch (std::exception& e) {
76882       {
76883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76884       };
76885     } catch (...) {
76886       {
76887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76888       };
76889     }
76890   }
76891 }
76892
76893
76894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
76895   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76896   unsigned int arg2 ;
76897
76898   arg1 = (Dali::Toolkit::TableView *)jarg1;
76899   arg2 = (unsigned int)jarg2;
76900   {
76901     try {
76902       (arg1)->DeleteRow(arg2);
76903     } catch (std::out_of_range& e) {
76904       {
76905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76906       };
76907     } catch (std::exception& e) {
76908       {
76909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76910       };
76911     } catch (...) {
76912       {
76913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76914       };
76915     }
76916   }
76917 }
76918
76919
76920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
76921   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76922   unsigned int arg2 ;
76923   std::vector< Dali::Actor > *arg3 = 0 ;
76924
76925   arg1 = (Dali::Toolkit::TableView *)jarg1;
76926   arg2 = (unsigned int)jarg2;
76927   arg3 = (std::vector< Dali::Actor > *)jarg3;
76928   if (!arg3) {
76929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
76930     return ;
76931   }
76932   {
76933     try {
76934       (arg1)->DeleteRow(arg2,*arg3);
76935     } catch (std::out_of_range& e) {
76936       {
76937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76938       };
76939     } catch (std::exception& e) {
76940       {
76941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76942       };
76943     } catch (...) {
76944       {
76945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76946       };
76947     }
76948   }
76949 }
76950
76951
76952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
76953   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76954   unsigned int arg2 ;
76955
76956   arg1 = (Dali::Toolkit::TableView *)jarg1;
76957   arg2 = (unsigned int)jarg2;
76958   {
76959     try {
76960       (arg1)->InsertColumn(arg2);
76961     } catch (std::out_of_range& e) {
76962       {
76963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76964       };
76965     } catch (std::exception& e) {
76966       {
76967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76968       };
76969     } catch (...) {
76970       {
76971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76972       };
76973     }
76974   }
76975 }
76976
76977
76978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
76979   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76980   unsigned int arg2 ;
76981
76982   arg1 = (Dali::Toolkit::TableView *)jarg1;
76983   arg2 = (unsigned int)jarg2;
76984   {
76985     try {
76986       (arg1)->DeleteColumn(arg2);
76987     } catch (std::out_of_range& e) {
76988       {
76989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76990       };
76991     } catch (std::exception& e) {
76992       {
76993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76994       };
76995     } catch (...) {
76996       {
76997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76998       };
76999     }
77000   }
77001 }
77002
77003
77004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
77005   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77006   unsigned int arg2 ;
77007   std::vector< Dali::Actor > *arg3 = 0 ;
77008
77009   arg1 = (Dali::Toolkit::TableView *)jarg1;
77010   arg2 = (unsigned int)jarg2;
77011   arg3 = (std::vector< Dali::Actor > *)jarg3;
77012   if (!arg3) {
77013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77014     return ;
77015   }
77016   {
77017     try {
77018       (arg1)->DeleteColumn(arg2,*arg3);
77019     } catch (std::out_of_range& e) {
77020       {
77021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77022       };
77023     } catch (std::exception& e) {
77024       {
77025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77026       };
77027     } catch (...) {
77028       {
77029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77030       };
77031     }
77032   }
77033 }
77034
77035
77036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
77037   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77038   unsigned int arg2 ;
77039   unsigned int arg3 ;
77040
77041   arg1 = (Dali::Toolkit::TableView *)jarg1;
77042   arg2 = (unsigned int)jarg2;
77043   arg3 = (unsigned int)jarg3;
77044   {
77045     try {
77046       (arg1)->Resize(arg2,arg3);
77047     } catch (std::out_of_range& e) {
77048       {
77049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77050       };
77051     } catch (std::exception& e) {
77052       {
77053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77054       };
77055     } catch (...) {
77056       {
77057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77058       };
77059     }
77060   }
77061 }
77062
77063
77064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
77065   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77066   unsigned int arg2 ;
77067   unsigned int arg3 ;
77068   std::vector< Dali::Actor > *arg4 = 0 ;
77069
77070   arg1 = (Dali::Toolkit::TableView *)jarg1;
77071   arg2 = (unsigned int)jarg2;
77072   arg3 = (unsigned int)jarg3;
77073   arg4 = (std::vector< Dali::Actor > *)jarg4;
77074   if (!arg4) {
77075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77076     return ;
77077   }
77078   {
77079     try {
77080       (arg1)->Resize(arg2,arg3,*arg4);
77081     } catch (std::out_of_range& e) {
77082       {
77083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77084       };
77085     } catch (std::exception& e) {
77086       {
77087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77088       };
77089     } catch (...) {
77090       {
77091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77092       };
77093     }
77094   }
77095 }
77096
77097
77098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
77099   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77100   Dali::Size arg2 ;
77101   Dali::Size *argp2 ;
77102
77103   arg1 = (Dali::Toolkit::TableView *)jarg1;
77104   argp2 = (Dali::Size *)jarg2;
77105   if (!argp2) {
77106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
77107     return ;
77108   }
77109   arg2 = *argp2;
77110   {
77111     try {
77112       (arg1)->SetCellPadding(arg2);
77113     } catch (std::out_of_range& e) {
77114       {
77115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77116       };
77117     } catch (std::exception& e) {
77118       {
77119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77120       };
77121     } catch (...) {
77122       {
77123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77124       };
77125     }
77126   }
77127 }
77128
77129
77130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
77131   void * jresult ;
77132   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77133   Dali::Size result;
77134
77135   arg1 = (Dali::Toolkit::TableView *)jarg1;
77136   {
77137     try {
77138       result = (arg1)->GetCellPadding();
77139     } catch (std::out_of_range& e) {
77140       {
77141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77142       };
77143     } catch (std::exception& e) {
77144       {
77145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77146       };
77147     } catch (...) {
77148       {
77149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77150       };
77151     }
77152   }
77153   jresult = new Dali::Size((const Dali::Size &)result);
77154   return jresult;
77155 }
77156
77157
77158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
77159   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77160   unsigned int arg2 ;
77161
77162   arg1 = (Dali::Toolkit::TableView *)jarg1;
77163   arg2 = (unsigned int)jarg2;
77164   {
77165     try {
77166       (arg1)->SetFitHeight(arg2);
77167     } catch (std::out_of_range& e) {
77168       {
77169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77170       };
77171     } catch (std::exception& e) {
77172       {
77173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77174       };
77175     } catch (...) {
77176       {
77177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77178       };
77179     }
77180   }
77181 }
77182
77183
77184 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
77185   unsigned int jresult ;
77186   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77187   unsigned int arg2 ;
77188   bool result;
77189
77190   arg1 = (Dali::Toolkit::TableView *)jarg1;
77191   arg2 = (unsigned int)jarg2;
77192   {
77193     try {
77194       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
77195     } catch (std::out_of_range& e) {
77196       {
77197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77198       };
77199     } catch (std::exception& e) {
77200       {
77201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77202       };
77203     } catch (...) {
77204       {
77205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77206       };
77207     }
77208   }
77209   jresult = result;
77210   return jresult;
77211 }
77212
77213
77214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
77215   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77216   unsigned int arg2 ;
77217
77218   arg1 = (Dali::Toolkit::TableView *)jarg1;
77219   arg2 = (unsigned int)jarg2;
77220   {
77221     try {
77222       (arg1)->SetFitWidth(arg2);
77223     } catch (std::out_of_range& e) {
77224       {
77225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77226       };
77227     } catch (std::exception& e) {
77228       {
77229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77230       };
77231     } catch (...) {
77232       {
77233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77234       };
77235     }
77236   }
77237 }
77238
77239
77240 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
77241   unsigned int jresult ;
77242   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77243   unsigned int arg2 ;
77244   bool result;
77245
77246   arg1 = (Dali::Toolkit::TableView *)jarg1;
77247   arg2 = (unsigned int)jarg2;
77248   {
77249     try {
77250       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
77251     } catch (std::out_of_range& e) {
77252       {
77253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77254       };
77255     } catch (std::exception& e) {
77256       {
77257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77258       };
77259     } catch (...) {
77260       {
77261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77262       };
77263     }
77264   }
77265   jresult = result;
77266   return jresult;
77267 }
77268
77269
77270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
77271   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77272   unsigned int arg2 ;
77273   float arg3 ;
77274
77275   arg1 = (Dali::Toolkit::TableView *)jarg1;
77276   arg2 = (unsigned int)jarg2;
77277   arg3 = (float)jarg3;
77278   {
77279     try {
77280       (arg1)->SetFixedHeight(arg2,arg3);
77281     } catch (std::out_of_range& e) {
77282       {
77283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77284       };
77285     } catch (std::exception& e) {
77286       {
77287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77288       };
77289     } catch (...) {
77290       {
77291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77292       };
77293     }
77294   }
77295 }
77296
77297
77298 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
77299   float jresult ;
77300   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77301   unsigned int arg2 ;
77302   float result;
77303
77304   arg1 = (Dali::Toolkit::TableView *)jarg1;
77305   arg2 = (unsigned int)jarg2;
77306   {
77307     try {
77308       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
77309     } catch (std::out_of_range& e) {
77310       {
77311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77312       };
77313     } catch (std::exception& e) {
77314       {
77315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77316       };
77317     } catch (...) {
77318       {
77319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77320       };
77321     }
77322   }
77323   jresult = result;
77324   return jresult;
77325 }
77326
77327
77328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
77329   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77330   unsigned int arg2 ;
77331   float arg3 ;
77332
77333   arg1 = (Dali::Toolkit::TableView *)jarg1;
77334   arg2 = (unsigned int)jarg2;
77335   arg3 = (float)jarg3;
77336   {
77337     try {
77338       (arg1)->SetRelativeHeight(arg2,arg3);
77339     } catch (std::out_of_range& e) {
77340       {
77341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77342       };
77343     } catch (std::exception& e) {
77344       {
77345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77346       };
77347     } catch (...) {
77348       {
77349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77350       };
77351     }
77352   }
77353 }
77354
77355
77356 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
77357   float jresult ;
77358   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77359   unsigned int arg2 ;
77360   float result;
77361
77362   arg1 = (Dali::Toolkit::TableView *)jarg1;
77363   arg2 = (unsigned int)jarg2;
77364   {
77365     try {
77366       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
77367     } catch (std::out_of_range& e) {
77368       {
77369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77370       };
77371     } catch (std::exception& e) {
77372       {
77373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77374       };
77375     } catch (...) {
77376       {
77377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77378       };
77379     }
77380   }
77381   jresult = result;
77382   return jresult;
77383 }
77384
77385
77386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
77387   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77388   unsigned int arg2 ;
77389   float arg3 ;
77390
77391   arg1 = (Dali::Toolkit::TableView *)jarg1;
77392   arg2 = (unsigned int)jarg2;
77393   arg3 = (float)jarg3;
77394   {
77395     try {
77396       (arg1)->SetFixedWidth(arg2,arg3);
77397     } catch (std::out_of_range& e) {
77398       {
77399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77400       };
77401     } catch (std::exception& e) {
77402       {
77403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77404       };
77405     } catch (...) {
77406       {
77407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77408       };
77409     }
77410   }
77411 }
77412
77413
77414 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
77415   float jresult ;
77416   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77417   unsigned int arg2 ;
77418   float result;
77419
77420   arg1 = (Dali::Toolkit::TableView *)jarg1;
77421   arg2 = (unsigned int)jarg2;
77422   {
77423     try {
77424       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
77425     } catch (std::out_of_range& e) {
77426       {
77427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77428       };
77429     } catch (std::exception& e) {
77430       {
77431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77432       };
77433     } catch (...) {
77434       {
77435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77436       };
77437     }
77438   }
77439   jresult = result;
77440   return jresult;
77441 }
77442
77443
77444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
77445   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77446   unsigned int arg2 ;
77447   float arg3 ;
77448
77449   arg1 = (Dali::Toolkit::TableView *)jarg1;
77450   arg2 = (unsigned int)jarg2;
77451   arg3 = (float)jarg3;
77452   {
77453     try {
77454       (arg1)->SetRelativeWidth(arg2,arg3);
77455     } catch (std::out_of_range& e) {
77456       {
77457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77458       };
77459     } catch (std::exception& e) {
77460       {
77461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77462       };
77463     } catch (...) {
77464       {
77465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77466       };
77467     }
77468   }
77469 }
77470
77471
77472 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
77473   float jresult ;
77474   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77475   unsigned int arg2 ;
77476   float result;
77477
77478   arg1 = (Dali::Toolkit::TableView *)jarg1;
77479   arg2 = (unsigned int)jarg2;
77480   {
77481     try {
77482       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
77483     } catch (std::out_of_range& e) {
77484       {
77485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77486       };
77487     } catch (std::exception& e) {
77488       {
77489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77490       };
77491     } catch (...) {
77492       {
77493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77494       };
77495     }
77496   }
77497   jresult = result;
77498   return jresult;
77499 }
77500
77501
77502 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
77503   unsigned int jresult ;
77504   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77505   unsigned int result;
77506
77507   arg1 = (Dali::Toolkit::TableView *)jarg1;
77508   {
77509     try {
77510       result = (unsigned int)(arg1)->GetRows();
77511     } catch (std::out_of_range& e) {
77512       {
77513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77514       };
77515     } catch (std::exception& e) {
77516       {
77517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77518       };
77519     } catch (...) {
77520       {
77521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77522       };
77523     }
77524   }
77525   jresult = result;
77526   return jresult;
77527 }
77528
77529
77530 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
77531   unsigned int jresult ;
77532   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77533   unsigned int result;
77534
77535   arg1 = (Dali::Toolkit::TableView *)jarg1;
77536   {
77537     try {
77538       result = (unsigned int)(arg1)->GetColumns();
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 = result;
77554   return jresult;
77555 }
77556
77557
77558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
77559   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77560   Dali::Toolkit::TableView::CellPosition arg2 ;
77561   Dali::HorizontalAlignment::Type arg3 ;
77562   Dali::VerticalAlignment::Type arg4 ;
77563   Dali::Toolkit::TableView::CellPosition *argp2 ;
77564
77565   arg1 = (Dali::Toolkit::TableView *)jarg1;
77566   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
77567   if (!argp2) {
77568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77569     return ;
77570   }
77571   arg2 = *argp2;
77572   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
77573   arg4 = (Dali::VerticalAlignment::Type)jarg4;
77574   {
77575     try {
77576       (arg1)->SetCellAlignment(arg2,arg3,arg4);
77577     } catch (std::out_of_range& e) {
77578       {
77579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77580       };
77581     } catch (std::exception& e) {
77582       {
77583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77584       };
77585     } catch (...) {
77586       {
77587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77588       };
77589     }
77590   }
77591 }
77592
77593
77594 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
77595   unsigned int jresult ;
77596   unsigned int result;
77597
77598   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
77599   jresult = result;
77600   return jresult;
77601 }
77602
77603
77604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_RENDERING_BACKEND_get() {
77605   int jresult ;
77606   int result;
77607
77608   result = (int)Dali::Toolkit::TextEditor::Property::RENDERING_BACKEND;
77609   jresult = (int)result;
77610   return jresult;
77611 }
77612
77613
77614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_get() {
77615   int jresult ;
77616   int result;
77617
77618   result = (int)Dali::Toolkit::TextEditor::Property::TEXT;
77619   jresult = (int)result;
77620   return jresult;
77621 }
77622
77623
77624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_COLOR_get() {
77625   int jresult ;
77626   int result;
77627
77628   result = (int)Dali::Toolkit::TextEditor::Property::TEXT_COLOR;
77629   jresult = (int)result;
77630   return jresult;
77631 }
77632
77633
77634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_FAMILY_get() {
77635   int jresult ;
77636   int result;
77637
77638   result = (int)Dali::Toolkit::TextEditor::Property::FONT_FAMILY;
77639   jresult = (int)result;
77640   return jresult;
77641 }
77642
77643
77644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_STYLE_get() {
77645   int jresult ;
77646   int result;
77647
77648   result = (int)Dali::Toolkit::TextEditor::Property::FONT_STYLE;
77649   jresult = (int)result;
77650   return jresult;
77651 }
77652
77653
77654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_POINT_SIZE_get() {
77655   int jresult ;
77656   int result;
77657
77658   result = (int)Dali::Toolkit::TextEditor::Property::POINT_SIZE;
77659   jresult = (int)result;
77660   return jresult;
77661 }
77662
77663
77664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_HORIZONTAL_ALIGNMENT_get() {
77665   int jresult ;
77666   int result;
77667
77668   result = (int)Dali::Toolkit::TextEditor::Property::HORIZONTAL_ALIGNMENT;
77669   jresult = (int)result;
77670   return jresult;
77671 }
77672
77673
77674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_THRESHOLD_get() {
77675   int jresult ;
77676   int result;
77677
77678   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_THRESHOLD;
77679   jresult = (int)result;
77680   return jresult;
77681 }
77682
77683
77684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_SPEED_get() {
77685   int jresult ;
77686   int result;
77687
77688   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_SPEED;
77689   jresult = (int)result;
77690   return jresult;
77691 }
77692
77693
77694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_PRIMARY_CURSOR_COLOR_get() {
77695   int jresult ;
77696   int result;
77697
77698   result = (int)Dali::Toolkit::TextEditor::Property::PRIMARY_CURSOR_COLOR;
77699   jresult = (int)result;
77700   return jresult;
77701 }
77702
77703
77704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SECONDARY_CURSOR_COLOR_get() {
77705   int jresult ;
77706   int result;
77707
77708   result = (int)Dali::Toolkit::TextEditor::Property::SECONDARY_CURSOR_COLOR;
77709   jresult = (int)result;
77710   return jresult;
77711 }
77712
77713
77714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_CURSOR_BLINK_get() {
77715   int jresult ;
77716   int result;
77717
77718   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_CURSOR_BLINK;
77719   jresult = (int)result;
77720   return jresult;
77721 }
77722
77723
77724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_INTERVAL_get() {
77725   int jresult ;
77726   int result;
77727
77728   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_INTERVAL;
77729   jresult = (int)result;
77730   return jresult;
77731 }
77732
77733
77734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_DURATION_get() {
77735   int jresult ;
77736   int result;
77737
77738   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_DURATION;
77739   jresult = (int)result;
77740   return jresult;
77741 }
77742
77743
77744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_WIDTH_get() {
77745   int jresult ;
77746   int result;
77747
77748   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_WIDTH;
77749   jresult = (int)result;
77750   return jresult;
77751 }
77752
77753
77754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_IMAGE_get() {
77755   int jresult ;
77756   int result;
77757
77758   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_IMAGE;
77759   jresult = (int)result;
77760   return jresult;
77761 }
77762
77763
77764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
77765   int jresult ;
77766   int result;
77767
77768   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_PRESSED_IMAGE;
77769   jresult = (int)result;
77770   return jresult;
77771 }
77772
77773
77774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
77775   int jresult ;
77776   int result;
77777
77778   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_LEFT;
77779   jresult = (int)result;
77780   return jresult;
77781 }
77782
77783
77784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
77785   int jresult ;
77786   int result;
77787
77788   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_RIGHT;
77789   jresult = (int)result;
77790   return jresult;
77791 }
77792
77793
77794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
77795   int jresult ;
77796   int result;
77797
77798   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
77799   jresult = (int)result;
77800   return jresult;
77801 }
77802
77803
77804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
77805   int jresult ;
77806   int result;
77807
77808   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
77809   jresult = (int)result;
77810   return jresult;
77811 }
77812
77813
77814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
77815   int jresult ;
77816   int result;
77817
77818   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
77819   jresult = (int)result;
77820   return jresult;
77821 }
77822
77823
77824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
77825   int jresult ;
77826   int result;
77827
77828   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
77829   jresult = (int)result;
77830   return jresult;
77831 }
77832
77833
77834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HIGHLIGHT_COLOR_get() {
77835   int jresult ;
77836   int result;
77837
77838   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HIGHLIGHT_COLOR;
77839   jresult = (int)result;
77840   return jresult;
77841 }
77842
77843
77844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_DECORATION_BOUNDING_BOX_get() {
77845   int jresult ;
77846   int result;
77847
77848   result = (int)Dali::Toolkit::TextEditor::Property::DECORATION_BOUNDING_BOX;
77849   jresult = (int)result;
77850   return jresult;
77851 }
77852
77853
77854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_MARKUP_get() {
77855   int jresult ;
77856   int result;
77857
77858   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_MARKUP;
77859   jresult = (int)result;
77860   return jresult;
77861 }
77862
77863
77864 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_COLOR_get() {
77865   int jresult ;
77866   int result;
77867
77868   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_COLOR;
77869   jresult = (int)result;
77870   return jresult;
77871 }
77872
77873
77874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_FAMILY_get() {
77875   int jresult ;
77876   int result;
77877
77878   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_FAMILY;
77879   jresult = (int)result;
77880   return jresult;
77881 }
77882
77883
77884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_STYLE_get() {
77885   int jresult ;
77886   int result;
77887
77888   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_STYLE;
77889   jresult = (int)result;
77890   return jresult;
77891 }
77892
77893
77894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_POINT_SIZE_get() {
77895   int jresult ;
77896   int result;
77897
77898   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_POINT_SIZE;
77899   jresult = (int)result;
77900   return jresult;
77901 }
77902
77903
77904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_LINE_SPACING_get() {
77905   int jresult ;
77906   int result;
77907
77908   result = (int)Dali::Toolkit::TextEditor::Property::LINE_SPACING;
77909   jresult = (int)result;
77910   return jresult;
77911 }
77912
77913
77914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_LINE_SPACING_get() {
77915   int jresult ;
77916   int result;
77917
77918   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_LINE_SPACING;
77919   jresult = (int)result;
77920   return jresult;
77921 }
77922
77923
77924 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_UNDERLINE_get() {
77925   int jresult ;
77926   int result;
77927
77928   result = (int)Dali::Toolkit::TextEditor::Property::UNDERLINE;
77929   jresult = (int)result;
77930   return jresult;
77931 }
77932
77933
77934 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_UNDERLINE_get() {
77935   int jresult ;
77936   int result;
77937
77938   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_UNDERLINE;
77939   jresult = (int)result;
77940   return jresult;
77941 }
77942
77943
77944 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SHADOW_get() {
77945   int jresult ;
77946   int result;
77947
77948   result = (int)Dali::Toolkit::TextEditor::Property::SHADOW;
77949   jresult = (int)result;
77950   return jresult;
77951 }
77952
77953
77954 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_SHADOW_get() {
77955   int jresult ;
77956   int result;
77957
77958   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_SHADOW;
77959   jresult = (int)result;
77960   return jresult;
77961 }
77962
77963
77964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_EMBOSS_get() {
77965   int jresult ;
77966   int result;
77967
77968   result = (int)Dali::Toolkit::TextEditor::Property::EMBOSS;
77969   jresult = (int)result;
77970   return jresult;
77971 }
77972
77973
77974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_EMBOSS_get() {
77975   int jresult ;
77976   int result;
77977
77978   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_EMBOSS;
77979   jresult = (int)result;
77980   return jresult;
77981 }
77982
77983
77984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_OUTLINE_get() {
77985   int jresult ;
77986   int result;
77987
77988   result = (int)Dali::Toolkit::TextEditor::Property::OUTLINE;
77989   jresult = (int)result;
77990   return jresult;
77991 }
77992
77993
77994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_OUTLINE_get() {
77995   int jresult ;
77996   int result;
77997
77998   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_OUTLINE;
77999   jresult = (int)result;
78000   return jresult;
78001 }
78002
78003
78004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_Property() {
78005   void * jresult ;
78006   Dali::Toolkit::TextEditor::Property *result = 0 ;
78007
78008   {
78009     try {
78010       result = (Dali::Toolkit::TextEditor::Property *)new Dali::Toolkit::TextEditor::Property();
78011     } catch (std::out_of_range& e) {
78012       {
78013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78014       };
78015     } catch (std::exception& e) {
78016       {
78017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78018       };
78019     } catch (...) {
78020       {
78021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78022       };
78023     }
78024   }
78025   jresult = (void *)result;
78026   return jresult;
78027 }
78028
78029
78030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_Property(void * jarg1) {
78031   Dali::Toolkit::TextEditor::Property *arg1 = (Dali::Toolkit::TextEditor::Property *) 0 ;
78032
78033   arg1 = (Dali::Toolkit::TextEditor::Property *)jarg1;
78034   {
78035     try {
78036       delete arg1;
78037     } catch (std::out_of_range& e) {
78038       {
78039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78040       };
78041     } catch (std::exception& e) {
78042       {
78043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78044       };
78045     } catch (...) {
78046       {
78047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78048       };
78049     }
78050   }
78051 }
78052
78053
78054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_InputStyle() {
78055   void * jresult ;
78056   Dali::Toolkit::TextEditor::InputStyle *result = 0 ;
78057
78058   {
78059     try {
78060       result = (Dali::Toolkit::TextEditor::InputStyle *)new Dali::Toolkit::TextEditor::InputStyle();
78061     } catch (std::out_of_range& e) {
78062       {
78063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78064       };
78065     } catch (std::exception& e) {
78066       {
78067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78068       };
78069     } catch (...) {
78070       {
78071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78072       };
78073     }
78074   }
78075   jresult = (void *)result;
78076   return jresult;
78077 }
78078
78079
78080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_InputStyle(void * jarg1) {
78081   Dali::Toolkit::TextEditor::InputStyle *arg1 = (Dali::Toolkit::TextEditor::InputStyle *) 0 ;
78082
78083   arg1 = (Dali::Toolkit::TextEditor::InputStyle *)jarg1;
78084   {
78085     try {
78086       delete arg1;
78087     } catch (std::out_of_range& e) {
78088       {
78089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78090       };
78091     } catch (std::exception& e) {
78092       {
78093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78094       };
78095     } catch (...) {
78096       {
78097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78098       };
78099     }
78100   }
78101 }
78102
78103
78104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_New() {
78105   void * jresult ;
78106   Dali::Toolkit::TextEditor result;
78107
78108   {
78109     try {
78110       result = Dali::Toolkit::TextEditor::New();
78111     } catch (std::out_of_range& e) {
78112       {
78113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78114       };
78115     } catch (std::exception& e) {
78116       {
78117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78118       };
78119     } catch (...) {
78120       {
78121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78122       };
78123     }
78124   }
78125   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
78126   return jresult;
78127 }
78128
78129
78130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_0() {
78131   void * jresult ;
78132   Dali::Toolkit::TextEditor *result = 0 ;
78133
78134   {
78135     try {
78136       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor();
78137     } catch (std::out_of_range& e) {
78138       {
78139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78140       };
78141     } catch (std::exception& e) {
78142       {
78143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78144       };
78145     } catch (...) {
78146       {
78147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78148       };
78149     }
78150   }
78151   jresult = (void *)result;
78152   return jresult;
78153 }
78154
78155
78156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_1(void * jarg1) {
78157   void * jresult ;
78158   Dali::Toolkit::TextEditor *arg1 = 0 ;
78159   Dali::Toolkit::TextEditor *result = 0 ;
78160
78161   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78162   if (!arg1) {
78163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
78164     return 0;
78165   }
78166   {
78167     try {
78168       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor((Dali::Toolkit::TextEditor const &)*arg1);
78169     } catch (std::out_of_range& e) {
78170       {
78171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78172       };
78173     } catch (std::exception& e) {
78174       {
78175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78176       };
78177     } catch (...) {
78178       {
78179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78180       };
78181     }
78182   }
78183   jresult = (void *)result;
78184   return jresult;
78185 }
78186
78187
78188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_Assign(void * jarg1, void * jarg2) {
78189   void * jresult ;
78190   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
78191   Dali::Toolkit::TextEditor *arg2 = 0 ;
78192   Dali::Toolkit::TextEditor *result = 0 ;
78193
78194   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78195   arg2 = (Dali::Toolkit::TextEditor *)jarg2;
78196   if (!arg2) {
78197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
78198     return 0;
78199   }
78200   {
78201     try {
78202       result = (Dali::Toolkit::TextEditor *) &(arg1)->operator =((Dali::Toolkit::TextEditor const &)*arg2);
78203     } catch (std::out_of_range& e) {
78204       {
78205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78206       };
78207     } catch (std::exception& e) {
78208       {
78209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78210       };
78211     } catch (...) {
78212       {
78213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78214       };
78215     }
78216   }
78217   jresult = (void *)result;
78218   return jresult;
78219 }
78220
78221
78222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor(void * jarg1) {
78223   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
78224
78225   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78226   {
78227     try {
78228       delete arg1;
78229     } catch (std::out_of_range& e) {
78230       {
78231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78232       };
78233     } catch (std::exception& e) {
78234       {
78235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78236       };
78237     } catch (...) {
78238       {
78239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78240       };
78241     }
78242   }
78243 }
78244
78245
78246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_DownCast(void * jarg1) {
78247   void * jresult ;
78248   Dali::BaseHandle arg1 ;
78249   Dali::BaseHandle *argp1 ;
78250   Dali::Toolkit::TextEditor result;
78251
78252   argp1 = (Dali::BaseHandle *)jarg1;
78253   if (!argp1) {
78254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78255     return 0;
78256   }
78257   arg1 = *argp1;
78258   {
78259     try {
78260       result = Dali::Toolkit::TextEditor::DownCast(arg1);
78261     } catch (std::out_of_range& e) {
78262       {
78263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78264       };
78265     } catch (std::exception& e) {
78266       {
78267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78268       };
78269     } catch (...) {
78270       {
78271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78272       };
78273     }
78274   }
78275   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
78276   return jresult;
78277 }
78278
78279
78280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_TextChangedSignal(void * jarg1) {
78281   void * jresult ;
78282   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
78283   Dali::Toolkit::TextEditor::TextChangedSignalType *result = 0 ;
78284
78285   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78286   {
78287     try {
78288       result = (Dali::Toolkit::TextEditor::TextChangedSignalType *) &(arg1)->TextChangedSignal();
78289     } catch (std::out_of_range& e) {
78290       {
78291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78292       };
78293     } catch (std::exception& e) {
78294       {
78295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78296       };
78297     } catch (...) {
78298       {
78299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78300       };
78301     }
78302   }
78303   jresult = (void *)result;
78304   return jresult;
78305 }
78306
78307
78308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_InputStyleChangedSignal(void * jarg1) {
78309   void * jresult ;
78310   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
78311   Dali::Toolkit::TextEditor::InputStyleChangedSignalType *result = 0 ;
78312
78313   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78314   {
78315     try {
78316       result = (Dali::Toolkit::TextEditor::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
78317     } catch (std::out_of_range& e) {
78318       {
78319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78320       };
78321     } catch (std::exception& e) {
78322       {
78323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78324       };
78325     } catch (...) {
78326       {
78327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78328       };
78329     }
78330   }
78331   jresult = (void *)result;
78332   return jresult;
78333 }
78334
78335
78336 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_RENDERING_BACKEND_get() {
78337   int jresult ;
78338   int result;
78339
78340   result = (int)Dali::Toolkit::TextField::Property::RENDERING_BACKEND;
78341   jresult = (int)result;
78342   return jresult;
78343 }
78344
78345
78346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_get() {
78347   int jresult ;
78348   int result;
78349
78350   result = (int)Dali::Toolkit::TextField::Property::TEXT;
78351   jresult = (int)result;
78352   return jresult;
78353 }
78354
78355
78356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_get() {
78357   int jresult ;
78358   int result;
78359
78360   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT;
78361   jresult = (int)result;
78362   return jresult;
78363 }
78364
78365
78366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_FOCUSED_get() {
78367   int jresult ;
78368   int result;
78369
78370   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_FOCUSED;
78371   jresult = (int)result;
78372   return jresult;
78373 }
78374
78375
78376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_FAMILY_get() {
78377   int jresult ;
78378   int result;
78379
78380   result = (int)Dali::Toolkit::TextField::Property::FONT_FAMILY;
78381   jresult = (int)result;
78382   return jresult;
78383 }
78384
78385
78386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_STYLE_get() {
78387   int jresult ;
78388   int result;
78389
78390   result = (int)Dali::Toolkit::TextField::Property::FONT_STYLE;
78391   jresult = (int)result;
78392   return jresult;
78393 }
78394
78395
78396 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_POINT_SIZE_get() {
78397   int jresult ;
78398   int result;
78399
78400   result = (int)Dali::Toolkit::TextField::Property::POINT_SIZE;
78401   jresult = (int)result;
78402   return jresult;
78403 }
78404
78405
78406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_MAX_LENGTH_get() {
78407   int jresult ;
78408   int result;
78409
78410   result = (int)Dali::Toolkit::TextField::Property::MAX_LENGTH;
78411   jresult = (int)result;
78412   return jresult;
78413 }
78414
78415
78416 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EXCEED_POLICY_get() {
78417   int jresult ;
78418   int result;
78419
78420   result = (int)Dali::Toolkit::TextField::Property::EXCEED_POLICY;
78421   jresult = (int)result;
78422   return jresult;
78423 }
78424
78425
78426 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_HORIZONTAL_ALIGNMENT_get() {
78427   int jresult ;
78428   int result;
78429
78430   result = (int)Dali::Toolkit::TextField::Property::HORIZONTAL_ALIGNMENT;
78431   jresult = (int)result;
78432   return jresult;
78433 }
78434
78435
78436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_VERTICAL_ALIGNMENT_get() {
78437   int jresult ;
78438   int result;
78439
78440   result = (int)Dali::Toolkit::TextField::Property::VERTICAL_ALIGNMENT;
78441   jresult = (int)result;
78442   return jresult;
78443 }
78444
78445
78446 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_COLOR_get() {
78447   int jresult ;
78448   int result;
78449
78450   result = (int)Dali::Toolkit::TextField::Property::TEXT_COLOR;
78451   jresult = (int)result;
78452   return jresult;
78453 }
78454
78455
78456 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_COLOR_get() {
78457   int jresult ;
78458   int result;
78459
78460   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_COLOR;
78461   jresult = (int)result;
78462   return jresult;
78463 }
78464
78465
78466 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_OFFSET_get() {
78467   int jresult ;
78468   int result;
78469
78470   result = (int)Dali::Toolkit::TextField::Property::SHADOW_OFFSET;
78471   jresult = (int)result;
78472   return jresult;
78473 }
78474
78475
78476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_COLOR_get() {
78477   int jresult ;
78478   int result;
78479
78480   result = (int)Dali::Toolkit::TextField::Property::SHADOW_COLOR;
78481   jresult = (int)result;
78482   return jresult;
78483 }
78484
78485
78486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PRIMARY_CURSOR_COLOR_get() {
78487   int jresult ;
78488   int result;
78489
78490   result = (int)Dali::Toolkit::TextField::Property::PRIMARY_CURSOR_COLOR;
78491   jresult = (int)result;
78492   return jresult;
78493 }
78494
78495
78496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SECONDARY_CURSOR_COLOR_get() {
78497   int jresult ;
78498   int result;
78499
78500   result = (int)Dali::Toolkit::TextField::Property::SECONDARY_CURSOR_COLOR;
78501   jresult = (int)result;
78502   return jresult;
78503 }
78504
78505
78506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_CURSOR_BLINK_get() {
78507   int jresult ;
78508   int result;
78509
78510   result = (int)Dali::Toolkit::TextField::Property::ENABLE_CURSOR_BLINK;
78511   jresult = (int)result;
78512   return jresult;
78513 }
78514
78515
78516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_INTERVAL_get() {
78517   int jresult ;
78518   int result;
78519
78520   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_INTERVAL;
78521   jresult = (int)result;
78522   return jresult;
78523 }
78524
78525
78526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_DURATION_get() {
78527   int jresult ;
78528   int result;
78529
78530   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_DURATION;
78531   jresult = (int)result;
78532   return jresult;
78533 }
78534
78535
78536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_WIDTH_get() {
78537   int jresult ;
78538   int result;
78539
78540   result = (int)Dali::Toolkit::TextField::Property::CURSOR_WIDTH;
78541   jresult = (int)result;
78542   return jresult;
78543 }
78544
78545
78546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_IMAGE_get() {
78547   int jresult ;
78548   int result;
78549
78550   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_IMAGE;
78551   jresult = (int)result;
78552   return jresult;
78553 }
78554
78555
78556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
78557   int jresult ;
78558   int result;
78559
78560   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_PRESSED_IMAGE;
78561   jresult = (int)result;
78562   return jresult;
78563 }
78564
78565
78566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_THRESHOLD_get() {
78567   int jresult ;
78568   int result;
78569
78570   result = (int)Dali::Toolkit::TextField::Property::SCROLL_THRESHOLD;
78571   jresult = (int)result;
78572   return jresult;
78573 }
78574
78575
78576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_SPEED_get() {
78577   int jresult ;
78578   int result;
78579
78580   result = (int)Dali::Toolkit::TextField::Property::SCROLL_SPEED;
78581   jresult = (int)result;
78582   return jresult;
78583 }
78584
78585
78586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
78587   int jresult ;
78588   int result;
78589
78590   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_LEFT;
78591   jresult = (int)result;
78592   return jresult;
78593 }
78594
78595
78596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
78597   int jresult ;
78598   int result;
78599
78600   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_RIGHT;
78601   jresult = (int)result;
78602   return jresult;
78603 }
78604
78605
78606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
78607   int jresult ;
78608   int result;
78609
78610   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
78611   jresult = (int)result;
78612   return jresult;
78613 }
78614
78615
78616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
78617   int jresult ;
78618   int result;
78619
78620   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
78621   jresult = (int)result;
78622   return jresult;
78623 }
78624
78625
78626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
78627   int jresult ;
78628   int result;
78629
78630   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
78631   jresult = (int)result;
78632   return jresult;
78633 }
78634
78635
78636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
78637   int jresult ;
78638   int result;
78639
78640   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
78641   jresult = (int)result;
78642   return jresult;
78643 }
78644
78645
78646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HIGHLIGHT_COLOR_get() {
78647   int jresult ;
78648   int result;
78649
78650   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HIGHLIGHT_COLOR;
78651   jresult = (int)result;
78652   return jresult;
78653 }
78654
78655
78656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_DECORATION_BOUNDING_BOX_get() {
78657   int jresult ;
78658   int result;
78659
78660   result = (int)Dali::Toolkit::TextField::Property::DECORATION_BOUNDING_BOX;
78661   jresult = (int)result;
78662   return jresult;
78663 }
78664
78665
78666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_METHOD_SETTINGS_get() {
78667   int jresult ;
78668   int result;
78669
78670   result = (int)Dali::Toolkit::TextField::Property::INPUT_METHOD_SETTINGS;
78671   jresult = (int)result;
78672   return jresult;
78673 }
78674
78675
78676 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_COLOR_get() {
78677   int jresult ;
78678   int result;
78679
78680   result = (int)Dali::Toolkit::TextField::Property::INPUT_COLOR;
78681   jresult = (int)result;
78682   return jresult;
78683 }
78684
78685
78686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_MARKUP_get() {
78687   int jresult ;
78688   int result;
78689
78690   result = (int)Dali::Toolkit::TextField::Property::ENABLE_MARKUP;
78691   jresult = (int)result;
78692   return jresult;
78693 }
78694
78695
78696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_FAMILY_get() {
78697   int jresult ;
78698   int result;
78699
78700   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_FAMILY;
78701   jresult = (int)result;
78702   return jresult;
78703 }
78704
78705
78706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_STYLE_get() {
78707   int jresult ;
78708   int result;
78709
78710   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_STYLE;
78711   jresult = (int)result;
78712   return jresult;
78713 }
78714
78715
78716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_POINT_SIZE_get() {
78717   int jresult ;
78718   int result;
78719
78720   result = (int)Dali::Toolkit::TextField::Property::INPUT_POINT_SIZE;
78721   jresult = (int)result;
78722   return jresult;
78723 }
78724
78725
78726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_UNDERLINE_get() {
78727   int jresult ;
78728   int result;
78729
78730   result = (int)Dali::Toolkit::TextField::Property::UNDERLINE;
78731   jresult = (int)result;
78732   return jresult;
78733 }
78734
78735
78736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_UNDERLINE_get() {
78737   int jresult ;
78738   int result;
78739
78740   result = (int)Dali::Toolkit::TextField::Property::INPUT_UNDERLINE;
78741   jresult = (int)result;
78742   return jresult;
78743 }
78744
78745
78746 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_get() {
78747   int jresult ;
78748   int result;
78749
78750   result = (int)Dali::Toolkit::TextField::Property::SHADOW;
78751   jresult = (int)result;
78752   return jresult;
78753 }
78754
78755
78756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_SHADOW_get() {
78757   int jresult ;
78758   int result;
78759
78760   result = (int)Dali::Toolkit::TextField::Property::INPUT_SHADOW;
78761   jresult = (int)result;
78762   return jresult;
78763 }
78764
78765
78766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EMBOSS_get() {
78767   int jresult ;
78768   int result;
78769
78770   result = (int)Dali::Toolkit::TextField::Property::EMBOSS;
78771   jresult = (int)result;
78772   return jresult;
78773 }
78774
78775
78776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_EMBOSS_get() {
78777   int jresult ;
78778   int result;
78779
78780   result = (int)Dali::Toolkit::TextField::Property::INPUT_EMBOSS;
78781   jresult = (int)result;
78782   return jresult;
78783 }
78784
78785
78786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_OUTLINE_get() {
78787   int jresult ;
78788   int result;
78789
78790   result = (int)Dali::Toolkit::TextField::Property::OUTLINE;
78791   jresult = (int)result;
78792   return jresult;
78793 }
78794
78795
78796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_OUTLINE_get() {
78797   int jresult ;
78798   int result;
78799
78800   result = (int)Dali::Toolkit::TextField::Property::INPUT_OUTLINE;
78801   jresult = (int)result;
78802   return jresult;
78803 }
78804
78805
78806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_Property() {
78807   void * jresult ;
78808   Dali::Toolkit::TextField::Property *result = 0 ;
78809
78810   {
78811     try {
78812       result = (Dali::Toolkit::TextField::Property *)new Dali::Toolkit::TextField::Property();
78813     } catch (std::out_of_range& e) {
78814       {
78815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78816       };
78817     } catch (std::exception& e) {
78818       {
78819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78820       };
78821     } catch (...) {
78822       {
78823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78824       };
78825     }
78826   }
78827   jresult = (void *)result;
78828   return jresult;
78829 }
78830
78831
78832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_Property(void * jarg1) {
78833   Dali::Toolkit::TextField::Property *arg1 = (Dali::Toolkit::TextField::Property *) 0 ;
78834
78835   arg1 = (Dali::Toolkit::TextField::Property *)jarg1;
78836   {
78837     try {
78838       delete arg1;
78839     } catch (std::out_of_range& e) {
78840       {
78841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78842       };
78843     } catch (std::exception& e) {
78844       {
78845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78846       };
78847     } catch (...) {
78848       {
78849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78850       };
78851     }
78852   }
78853 }
78854
78855
78856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_InputStyle() {
78857   void * jresult ;
78858   Dali::Toolkit::TextField::InputStyle *result = 0 ;
78859
78860   {
78861     try {
78862       result = (Dali::Toolkit::TextField::InputStyle *)new Dali::Toolkit::TextField::InputStyle();
78863     } catch (std::out_of_range& e) {
78864       {
78865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78866       };
78867     } catch (std::exception& e) {
78868       {
78869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78870       };
78871     } catch (...) {
78872       {
78873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78874       };
78875     }
78876   }
78877   jresult = (void *)result;
78878   return jresult;
78879 }
78880
78881
78882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_InputStyle(void * jarg1) {
78883   Dali::Toolkit::TextField::InputStyle *arg1 = (Dali::Toolkit::TextField::InputStyle *) 0 ;
78884
78885   arg1 = (Dali::Toolkit::TextField::InputStyle *)jarg1;
78886   {
78887     try {
78888       delete arg1;
78889     } catch (std::out_of_range& e) {
78890       {
78891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78892       };
78893     } catch (std::exception& e) {
78894       {
78895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78896       };
78897     } catch (...) {
78898       {
78899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78900       };
78901     }
78902   }
78903 }
78904
78905
78906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_New() {
78907   void * jresult ;
78908   Dali::Toolkit::TextField result;
78909
78910   {
78911     try {
78912       result = Dali::Toolkit::TextField::New();
78913     } catch (std::out_of_range& e) {
78914       {
78915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78916       };
78917     } catch (std::exception& e) {
78918       {
78919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78920       };
78921     } catch (...) {
78922       {
78923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78924       };
78925     }
78926   }
78927   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
78928   return jresult;
78929 }
78930
78931
78932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_0() {
78933   void * jresult ;
78934   Dali::Toolkit::TextField *result = 0 ;
78935
78936   {
78937     try {
78938       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField();
78939     } catch (std::out_of_range& e) {
78940       {
78941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78942       };
78943     } catch (std::exception& e) {
78944       {
78945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78946       };
78947     } catch (...) {
78948       {
78949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78950       };
78951     }
78952   }
78953   jresult = (void *)result;
78954   return jresult;
78955 }
78956
78957
78958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_1(void * jarg1) {
78959   void * jresult ;
78960   Dali::Toolkit::TextField *arg1 = 0 ;
78961   Dali::Toolkit::TextField *result = 0 ;
78962
78963   arg1 = (Dali::Toolkit::TextField *)jarg1;
78964   if (!arg1) {
78965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
78966     return 0;
78967   }
78968   {
78969     try {
78970       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField((Dali::Toolkit::TextField const &)*arg1);
78971     } catch (std::out_of_range& e) {
78972       {
78973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78974       };
78975     } catch (std::exception& e) {
78976       {
78977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78978       };
78979     } catch (...) {
78980       {
78981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78982       };
78983     }
78984   }
78985   jresult = (void *)result;
78986   return jresult;
78987 }
78988
78989
78990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_Assign(void * jarg1, void * jarg2) {
78991   void * jresult ;
78992   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78993   Dali::Toolkit::TextField *arg2 = 0 ;
78994   Dali::Toolkit::TextField *result = 0 ;
78995
78996   arg1 = (Dali::Toolkit::TextField *)jarg1;
78997   arg2 = (Dali::Toolkit::TextField *)jarg2;
78998   if (!arg2) {
78999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
79000     return 0;
79001   }
79002   {
79003     try {
79004       result = (Dali::Toolkit::TextField *) &(arg1)->operator =((Dali::Toolkit::TextField const &)*arg2);
79005     } catch (std::out_of_range& e) {
79006       {
79007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79008       };
79009     } catch (std::exception& e) {
79010       {
79011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79012       };
79013     } catch (...) {
79014       {
79015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79016       };
79017     }
79018   }
79019   jresult = (void *)result;
79020   return jresult;
79021 }
79022
79023
79024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField(void * jarg1) {
79025   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
79026
79027   arg1 = (Dali::Toolkit::TextField *)jarg1;
79028   {
79029     try {
79030       delete arg1;
79031     } catch (std::out_of_range& e) {
79032       {
79033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79034       };
79035     } catch (std::exception& e) {
79036       {
79037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79038       };
79039     } catch (...) {
79040       {
79041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79042       };
79043     }
79044   }
79045 }
79046
79047
79048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_DownCast(void * jarg1) {
79049   void * jresult ;
79050   Dali::BaseHandle arg1 ;
79051   Dali::BaseHandle *argp1 ;
79052   Dali::Toolkit::TextField result;
79053
79054   argp1 = (Dali::BaseHandle *)jarg1;
79055   if (!argp1) {
79056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79057     return 0;
79058   }
79059   arg1 = *argp1;
79060   {
79061     try {
79062       result = Dali::Toolkit::TextField::DownCast(arg1);
79063     } catch (std::out_of_range& e) {
79064       {
79065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79066       };
79067     } catch (std::exception& e) {
79068       {
79069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79070       };
79071     } catch (...) {
79072       {
79073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79074       };
79075     }
79076   }
79077   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
79078   return jresult;
79079 }
79080
79081
79082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_TextChangedSignal(void * jarg1) {
79083   void * jresult ;
79084   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
79085   Dali::Toolkit::TextField::TextChangedSignalType *result = 0 ;
79086
79087   arg1 = (Dali::Toolkit::TextField *)jarg1;
79088   {
79089     try {
79090       result = (Dali::Toolkit::TextField::TextChangedSignalType *) &(arg1)->TextChangedSignal();
79091     } catch (std::out_of_range& e) {
79092       {
79093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79094       };
79095     } catch (std::exception& e) {
79096       {
79097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79098       };
79099     } catch (...) {
79100       {
79101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79102       };
79103     }
79104   }
79105   jresult = (void *)result;
79106   return jresult;
79107 }
79108
79109
79110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_MaxLengthReachedSignal(void * jarg1) {
79111   void * jresult ;
79112   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
79113   Dali::Toolkit::TextField::MaxLengthReachedSignalType *result = 0 ;
79114
79115   arg1 = (Dali::Toolkit::TextField *)jarg1;
79116   {
79117     try {
79118       result = (Dali::Toolkit::TextField::MaxLengthReachedSignalType *) &(arg1)->MaxLengthReachedSignal();
79119     } catch (std::out_of_range& e) {
79120       {
79121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79122       };
79123     } catch (std::exception& e) {
79124       {
79125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79126       };
79127     } catch (...) {
79128       {
79129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79130       };
79131     }
79132   }
79133   jresult = (void *)result;
79134   return jresult;
79135 }
79136
79137
79138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_InputStyleChangedSignal(void * jarg1) {
79139   void * jresult ;
79140   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
79141   Dali::Toolkit::TextField::InputStyleChangedSignalType *result = 0 ;
79142
79143   arg1 = (Dali::Toolkit::TextField *)jarg1;
79144   {
79145     try {
79146       result = (Dali::Toolkit::TextField::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
79147     } catch (std::out_of_range& e) {
79148       {
79149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79150       };
79151     } catch (std::exception& e) {
79152       {
79153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79154       };
79155     } catch (...) {
79156       {
79157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79158       };
79159     }
79160   }
79161   jresult = (void *)result;
79162   return jresult;
79163 }
79164
79165
79166 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
79167   int jresult ;
79168   int result;
79169
79170   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
79171   jresult = (int)result;
79172   return jresult;
79173 }
79174
79175
79176 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
79177   int jresult ;
79178   int result;
79179
79180   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
79181   jresult = (int)result;
79182   return jresult;
79183 }
79184
79185
79186 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
79187   int jresult ;
79188   int result;
79189
79190   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
79191   jresult = (int)result;
79192   return jresult;
79193 }
79194
79195
79196 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
79197   int jresult ;
79198   int result;
79199
79200   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
79201   jresult = (int)result;
79202   return jresult;
79203 }
79204
79205
79206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
79207   int jresult ;
79208   int result;
79209
79210   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
79211   jresult = (int)result;
79212   return jresult;
79213 }
79214
79215
79216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
79217   int jresult ;
79218   int result;
79219
79220   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
79221   jresult = (int)result;
79222   return jresult;
79223 }
79224
79225
79226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
79227   int jresult ;
79228   int result;
79229
79230   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
79231   jresult = (int)result;
79232   return jresult;
79233 }
79234
79235
79236 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
79237   int jresult ;
79238   int result;
79239
79240   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
79241   jresult = (int)result;
79242   return jresult;
79243 }
79244
79245
79246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
79247   int jresult ;
79248   int result;
79249
79250   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
79251   jresult = (int)result;
79252   return jresult;
79253 }
79254
79255
79256 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
79257   int jresult ;
79258   int result;
79259
79260   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
79261   jresult = (int)result;
79262   return jresult;
79263 }
79264
79265
79266 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
79267   int jresult ;
79268   int result;
79269
79270   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
79271   jresult = (int)result;
79272   return jresult;
79273 }
79274
79275
79276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
79277   int jresult ;
79278   int result;
79279
79280   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
79281   jresult = (int)result;
79282   return jresult;
79283 }
79284
79285
79286 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
79287   int jresult ;
79288   int result;
79289
79290   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
79291   jresult = (int)result;
79292   return jresult;
79293 }
79294
79295
79296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
79297   int jresult ;
79298   int result;
79299
79300   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
79301   jresult = (int)result;
79302   return jresult;
79303 }
79304
79305
79306 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
79307   int jresult ;
79308   int result;
79309
79310   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
79311   jresult = (int)result;
79312   return jresult;
79313 }
79314
79315
79316 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
79317   int jresult ;
79318   int result;
79319
79320   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
79321   jresult = (int)result;
79322   return jresult;
79323 }
79324
79325
79326 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
79327   int jresult ;
79328   int result;
79329
79330   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
79331   jresult = (int)result;
79332   return jresult;
79333 }
79334
79335
79336 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
79337   int jresult ;
79338   int result;
79339
79340   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
79341   jresult = (int)result;
79342   return jresult;
79343 }
79344
79345
79346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
79347   int jresult ;
79348   int result;
79349
79350   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
79351   jresult = (int)result;
79352   return jresult;
79353 }
79354
79355
79356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
79357   int jresult ;
79358   int result;
79359
79360   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
79361   jresult = (int)result;
79362   return jresult;
79363 }
79364
79365
79366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
79367   int jresult ;
79368   int result;
79369
79370   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
79371   jresult = (int)result;
79372   return jresult;
79373 }
79374
79375
79376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
79377   int jresult ;
79378   int result;
79379
79380   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
79381   jresult = (int)result;
79382   return jresult;
79383 }
79384
79385
79386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
79387   int jresult ;
79388   int result;
79389
79390   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
79391   jresult = (int)result;
79392   return jresult;
79393 }
79394
79395
79396 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
79397   int jresult ;
79398   int result;
79399
79400   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
79401   jresult = (int)result;
79402   return jresult;
79403 }
79404
79405
79406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
79407   void * jresult ;
79408   Dali::Toolkit::TextLabel::Property *result = 0 ;
79409
79410   {
79411     try {
79412       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
79413     } catch (std::out_of_range& e) {
79414       {
79415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79416       };
79417     } catch (std::exception& e) {
79418       {
79419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79420       };
79421     } catch (...) {
79422       {
79423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79424       };
79425     }
79426   }
79427   jresult = (void *)result;
79428   return jresult;
79429 }
79430
79431
79432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
79433   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
79434
79435   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
79436   {
79437     try {
79438       delete arg1;
79439     } catch (std::out_of_range& e) {
79440       {
79441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79442       };
79443     } catch (std::exception& e) {
79444       {
79445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79446       };
79447     } catch (...) {
79448       {
79449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79450       };
79451     }
79452   }
79453 }
79454
79455
79456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
79457   void * jresult ;
79458   Dali::Toolkit::TextLabel result;
79459
79460   {
79461     try {
79462       result = Dali::Toolkit::TextLabel::New();
79463     } catch (std::out_of_range& e) {
79464       {
79465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79466       };
79467     } catch (std::exception& e) {
79468       {
79469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79470       };
79471     } catch (...) {
79472       {
79473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79474       };
79475     }
79476   }
79477   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79478   return jresult;
79479 }
79480
79481
79482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
79483   void * jresult ;
79484   std::string *arg1 = 0 ;
79485   Dali::Toolkit::TextLabel result;
79486
79487   if (!jarg1) {
79488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79489     return 0;
79490   }
79491   std::string arg1_str(jarg1);
79492   arg1 = &arg1_str;
79493   {
79494     try {
79495       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
79496     } catch (std::out_of_range& e) {
79497       {
79498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79499       };
79500     } catch (std::exception& e) {
79501       {
79502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79503       };
79504     } catch (...) {
79505       {
79506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79507       };
79508     }
79509   }
79510   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79511
79512   //argout typemap for const std::string&
79513
79514   return jresult;
79515 }
79516
79517
79518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
79519   void * jresult ;
79520   Dali::Toolkit::TextLabel *result = 0 ;
79521
79522   {
79523     try {
79524       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
79525     } catch (std::out_of_range& e) {
79526       {
79527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79528       };
79529     } catch (std::exception& e) {
79530       {
79531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79532       };
79533     } catch (...) {
79534       {
79535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79536       };
79537     }
79538   }
79539   jresult = (void *)result;
79540   return jresult;
79541 }
79542
79543
79544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
79545   void * jresult ;
79546   Dali::Toolkit::TextLabel *arg1 = 0 ;
79547   Dali::Toolkit::TextLabel *result = 0 ;
79548
79549   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79550   if (!arg1) {
79551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
79552     return 0;
79553   }
79554   {
79555     try {
79556       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
79557     } catch (std::out_of_range& e) {
79558       {
79559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79560       };
79561     } catch (std::exception& e) {
79562       {
79563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79564       };
79565     } catch (...) {
79566       {
79567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79568       };
79569     }
79570   }
79571   jresult = (void *)result;
79572   return jresult;
79573 }
79574
79575
79576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
79577   void * jresult ;
79578   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
79579   Dali::Toolkit::TextLabel *arg2 = 0 ;
79580   Dali::Toolkit::TextLabel *result = 0 ;
79581
79582   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79583   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
79584   if (!arg2) {
79585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
79586     return 0;
79587   }
79588   {
79589     try {
79590       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
79591     } catch (std::out_of_range& e) {
79592       {
79593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79594       };
79595     } catch (std::exception& e) {
79596       {
79597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79598       };
79599     } catch (...) {
79600       {
79601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79602       };
79603     }
79604   }
79605   jresult = (void *)result;
79606   return jresult;
79607 }
79608
79609
79610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
79611   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
79612
79613   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79614   {
79615     try {
79616       delete arg1;
79617     } catch (std::out_of_range& e) {
79618       {
79619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79620       };
79621     } catch (std::exception& e) {
79622       {
79623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79624       };
79625     } catch (...) {
79626       {
79627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79628       };
79629     }
79630   }
79631 }
79632
79633
79634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
79635   void * jresult ;
79636   Dali::BaseHandle arg1 ;
79637   Dali::BaseHandle *argp1 ;
79638   Dali::Toolkit::TextLabel result;
79639
79640   argp1 = (Dali::BaseHandle *)jarg1;
79641   if (!argp1) {
79642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79643     return 0;
79644   }
79645   arg1 = *argp1;
79646   {
79647     try {
79648       result = Dali::Toolkit::TextLabel::DownCast(arg1);
79649     } catch (std::out_of_range& e) {
79650       {
79651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79652       };
79653     } catch (std::exception& e) {
79654       {
79655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79656       };
79657     } catch (...) {
79658       {
79659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79660       };
79661     }
79662   }
79663   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79664   return jresult;
79665 }
79666
79667
79668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
79669   void * jresult ;
79670   Dali::Toolkit::AccessibilityManager *result = 0 ;
79671
79672   {
79673     try {
79674       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
79675     } catch (std::out_of_range& e) {
79676       {
79677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79678       };
79679     } catch (std::exception& e) {
79680       {
79681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79682       };
79683     } catch (...) {
79684       {
79685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79686       };
79687     }
79688   }
79689   jresult = (void *)result;
79690   return jresult;
79691 }
79692
79693
79694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
79695   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79696
79697   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79698   {
79699     try {
79700       delete arg1;
79701     } catch (std::out_of_range& e) {
79702       {
79703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79704       };
79705     } catch (std::exception& e) {
79706       {
79707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79708       };
79709     } catch (...) {
79710       {
79711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79712       };
79713     }
79714   }
79715 }
79716
79717
79718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
79719   void * jresult ;
79720   Dali::Toolkit::AccessibilityManager result;
79721
79722   {
79723     try {
79724       result = Dali::Toolkit::AccessibilityManager::Get();
79725     } catch (std::out_of_range& e) {
79726       {
79727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79728       };
79729     } catch (std::exception& e) {
79730       {
79731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79732       };
79733     } catch (...) {
79734       {
79735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79736       };
79737     }
79738   }
79739   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
79740   return jresult;
79741 }
79742
79743
79744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
79745   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79746   Dali::Actor arg2 ;
79747   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79748   std::string *arg4 = 0 ;
79749   Dali::Actor *argp2 ;
79750
79751   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79752   argp2 = (Dali::Actor *)jarg2;
79753   if (!argp2) {
79754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79755     return ;
79756   }
79757   arg2 = *argp2;
79758   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79759   if (!jarg4) {
79760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79761     return ;
79762   }
79763   std::string arg4_str(jarg4);
79764   arg4 = &arg4_str;
79765   {
79766     try {
79767       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
79768     } catch (std::out_of_range& e) {
79769       {
79770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79771       };
79772     } catch (std::exception& e) {
79773       {
79774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79775       };
79776     } catch (...) {
79777       {
79778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79779       };
79780     }
79781   }
79782
79783   //argout typemap for const std::string&
79784
79785 }
79786
79787
79788 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
79789   char * jresult ;
79790   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79791   Dali::Actor arg2 ;
79792   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79793   Dali::Actor *argp2 ;
79794   std::string result;
79795
79796   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79797   argp2 = (Dali::Actor *)jarg2;
79798   if (!argp2) {
79799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79800     return 0;
79801   }
79802   arg2 = *argp2;
79803   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79804   {
79805     try {
79806       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
79807     } catch (std::out_of_range& e) {
79808       {
79809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79810       };
79811     } catch (std::exception& e) {
79812       {
79813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79814       };
79815     } catch (...) {
79816       {
79817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79818       };
79819     }
79820   }
79821   jresult = SWIG_csharp_string_callback((&result)->c_str());
79822   return jresult;
79823 }
79824
79825
79826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
79827   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79828   Dali::Actor arg2 ;
79829   unsigned int arg3 ;
79830   Dali::Actor *argp2 ;
79831
79832   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79833   argp2 = (Dali::Actor *)jarg2;
79834   if (!argp2) {
79835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79836     return ;
79837   }
79838   arg2 = *argp2;
79839   arg3 = (unsigned int)jarg3;
79840   {
79841     try {
79842       (arg1)->SetFocusOrder(arg2,arg3);
79843     } catch (std::out_of_range& e) {
79844       {
79845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79846       };
79847     } catch (std::exception& e) {
79848       {
79849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79850       };
79851     } catch (...) {
79852       {
79853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79854       };
79855     }
79856   }
79857 }
79858
79859
79860 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
79861   unsigned int jresult ;
79862   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79863   Dali::Actor arg2 ;
79864   Dali::Actor *argp2 ;
79865   unsigned int result;
79866
79867   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79868   argp2 = (Dali::Actor *)jarg2;
79869   if (!argp2) {
79870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79871     return 0;
79872   }
79873   arg2 = *argp2;
79874   {
79875     try {
79876       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
79877     } catch (std::out_of_range& e) {
79878       {
79879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79880       };
79881     } catch (std::exception& e) {
79882       {
79883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79884       };
79885     } catch (...) {
79886       {
79887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79888       };
79889     }
79890   }
79891   jresult = result;
79892   return jresult;
79893 }
79894
79895
79896 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
79897   unsigned int jresult ;
79898   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79899   unsigned int result;
79900
79901   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79902   {
79903     try {
79904       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
79905     } catch (std::out_of_range& e) {
79906       {
79907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79908       };
79909     } catch (std::exception& e) {
79910       {
79911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79912       };
79913     } catch (...) {
79914       {
79915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79916       };
79917     }
79918   }
79919   jresult = result;
79920   return jresult;
79921 }
79922
79923
79924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
79925   void * jresult ;
79926   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79927   unsigned int arg2 ;
79928   Dali::Actor result;
79929
79930   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79931   arg2 = (unsigned int)jarg2;
79932   {
79933     try {
79934       result = (arg1)->GetActorByFocusOrder(arg2);
79935     } catch (std::out_of_range& e) {
79936       {
79937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79938       };
79939     } catch (std::exception& e) {
79940       {
79941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79942       };
79943     } catch (...) {
79944       {
79945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79946       };
79947     }
79948   }
79949   jresult = new Dali::Actor((const Dali::Actor &)result);
79950   return jresult;
79951 }
79952
79953
79954 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
79955   unsigned int jresult ;
79956   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79957   Dali::Actor arg2 ;
79958   Dali::Actor *argp2 ;
79959   bool result;
79960
79961   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79962   argp2 = (Dali::Actor *)jarg2;
79963   if (!argp2) {
79964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79965     return 0;
79966   }
79967   arg2 = *argp2;
79968   {
79969     try {
79970       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
79971     } catch (std::out_of_range& e) {
79972       {
79973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79974       };
79975     } catch (std::exception& e) {
79976       {
79977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79978       };
79979     } catch (...) {
79980       {
79981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79982       };
79983     }
79984   }
79985   jresult = result;
79986   return jresult;
79987 }
79988
79989
79990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
79991   void * jresult ;
79992   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79993   Dali::Actor result;
79994
79995   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79996   {
79997     try {
79998       result = (arg1)->GetCurrentFocusActor();
79999     } catch (std::out_of_range& e) {
80000       {
80001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80002       };
80003     } catch (std::exception& e) {
80004       {
80005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80006       };
80007     } catch (...) {
80008       {
80009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80010       };
80011     }
80012   }
80013   jresult = new Dali::Actor((const Dali::Actor &)result);
80014   return jresult;
80015 }
80016
80017
80018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
80019   void * jresult ;
80020   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80021   Dali::Actor result;
80022
80023   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80024   {
80025     try {
80026       result = (arg1)->GetCurrentFocusGroup();
80027     } catch (std::out_of_range& e) {
80028       {
80029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80030       };
80031     } catch (std::exception& e) {
80032       {
80033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80034       };
80035     } catch (...) {
80036       {
80037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80038       };
80039     }
80040   }
80041   jresult = new Dali::Actor((const Dali::Actor &)result);
80042   return jresult;
80043 }
80044
80045
80046 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
80047   unsigned int jresult ;
80048   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80049   unsigned int result;
80050
80051   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80052   {
80053     try {
80054       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
80055     } catch (std::out_of_range& e) {
80056       {
80057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80058       };
80059     } catch (std::exception& e) {
80060       {
80061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80062       };
80063     } catch (...) {
80064       {
80065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80066       };
80067     }
80068   }
80069   jresult = result;
80070   return jresult;
80071 }
80072
80073
80074 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
80075   unsigned int jresult ;
80076   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80077   bool result;
80078
80079   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80080   {
80081     try {
80082       result = (bool)(arg1)->MoveFocusForward();
80083     } catch (std::out_of_range& e) {
80084       {
80085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80086       };
80087     } catch (std::exception& e) {
80088       {
80089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80090       };
80091     } catch (...) {
80092       {
80093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80094       };
80095     }
80096   }
80097   jresult = result;
80098   return jresult;
80099 }
80100
80101
80102 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
80103   unsigned int jresult ;
80104   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80105   bool result;
80106
80107   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80108   {
80109     try {
80110       result = (bool)(arg1)->MoveFocusBackward();
80111     } catch (std::out_of_range& e) {
80112       {
80113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80114       };
80115     } catch (std::exception& e) {
80116       {
80117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80118       };
80119     } catch (...) {
80120       {
80121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80122       };
80123     }
80124   }
80125   jresult = result;
80126   return jresult;
80127 }
80128
80129
80130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
80131   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80132
80133   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80134   {
80135     try {
80136       (arg1)->ClearFocus();
80137     } catch (std::out_of_range& e) {
80138       {
80139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80140       };
80141     } catch (std::exception& e) {
80142       {
80143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80144       };
80145     } catch (...) {
80146       {
80147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80148       };
80149     }
80150   }
80151 }
80152
80153
80154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
80155   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80156
80157   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80158   {
80159     try {
80160       (arg1)->Reset();
80161     } catch (std::out_of_range& e) {
80162       {
80163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80164       };
80165     } catch (std::exception& e) {
80166       {
80167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80168       };
80169     } catch (...) {
80170       {
80171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80172       };
80173     }
80174   }
80175 }
80176
80177
80178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
80179   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80180   Dali::Actor arg2 ;
80181   bool arg3 ;
80182   Dali::Actor *argp2 ;
80183
80184   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80185   argp2 = (Dali::Actor *)jarg2;
80186   if (!argp2) {
80187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80188     return ;
80189   }
80190   arg2 = *argp2;
80191   arg3 = jarg3 ? true : false;
80192   {
80193     try {
80194       (arg1)->SetFocusGroup(arg2,arg3);
80195     } catch (std::out_of_range& e) {
80196       {
80197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80198       };
80199     } catch (std::exception& e) {
80200       {
80201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80202       };
80203     } catch (...) {
80204       {
80205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80206       };
80207     }
80208   }
80209 }
80210
80211
80212 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
80213   unsigned int jresult ;
80214   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80215   Dali::Actor arg2 ;
80216   Dali::Actor *argp2 ;
80217   bool result;
80218
80219   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80220   argp2 = (Dali::Actor *)jarg2;
80221   if (!argp2) {
80222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80223     return 0;
80224   }
80225   arg2 = *argp2;
80226   {
80227     try {
80228       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
80229     } catch (std::out_of_range& e) {
80230       {
80231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80232       };
80233     } catch (std::exception& e) {
80234       {
80235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80236       };
80237     } catch (...) {
80238       {
80239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80240       };
80241     }
80242   }
80243   jresult = result;
80244   return jresult;
80245 }
80246
80247
80248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
80249   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80250   bool arg2 ;
80251
80252   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80253   arg2 = jarg2 ? true : false;
80254   {
80255     try {
80256       (arg1)->SetGroupMode(arg2);
80257     } catch (std::out_of_range& e) {
80258       {
80259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80260       };
80261     } catch (std::exception& e) {
80262       {
80263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80264       };
80265     } catch (...) {
80266       {
80267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80268       };
80269     }
80270   }
80271 }
80272
80273
80274 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
80275   unsigned int jresult ;
80276   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80277   bool result;
80278
80279   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80280   {
80281     try {
80282       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
80283     } catch (std::out_of_range& e) {
80284       {
80285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80286       };
80287     } catch (std::exception& e) {
80288       {
80289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80290       };
80291     } catch (...) {
80292       {
80293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80294       };
80295     }
80296   }
80297   jresult = result;
80298   return jresult;
80299 }
80300
80301
80302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
80303   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80304   bool arg2 ;
80305
80306   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80307   arg2 = jarg2 ? true : false;
80308   {
80309     try {
80310       (arg1)->SetWrapMode(arg2);
80311     } catch (std::out_of_range& e) {
80312       {
80313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80314       };
80315     } catch (std::exception& e) {
80316       {
80317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80318       };
80319     } catch (...) {
80320       {
80321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80322       };
80323     }
80324   }
80325 }
80326
80327
80328 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
80329   unsigned int jresult ;
80330   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80331   bool result;
80332
80333   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80334   {
80335     try {
80336       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
80337     } catch (std::out_of_range& e) {
80338       {
80339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80340       };
80341     } catch (std::exception& e) {
80342       {
80343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80344       };
80345     } catch (...) {
80346       {
80347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80348       };
80349     }
80350   }
80351   jresult = result;
80352   return jresult;
80353 }
80354
80355
80356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
80357   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80358   Dali::Actor arg2 ;
80359   Dali::Actor *argp2 ;
80360
80361   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80362   argp2 = (Dali::Actor *)jarg2;
80363   if (!argp2) {
80364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80365     return ;
80366   }
80367   arg2 = *argp2;
80368   {
80369     try {
80370       (arg1)->SetFocusIndicatorActor(arg2);
80371     } catch (std::out_of_range& e) {
80372       {
80373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80374       };
80375     } catch (std::exception& e) {
80376       {
80377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80378       };
80379     } catch (...) {
80380       {
80381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80382       };
80383     }
80384   }
80385 }
80386
80387
80388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
80389   void * jresult ;
80390   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80391   Dali::Actor result;
80392
80393   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80394   {
80395     try {
80396       result = (arg1)->GetFocusIndicatorActor();
80397     } catch (std::out_of_range& e) {
80398       {
80399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80400       };
80401     } catch (std::exception& e) {
80402       {
80403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80404       };
80405     } catch (...) {
80406       {
80407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80408       };
80409     }
80410   }
80411   jresult = new Dali::Actor((const Dali::Actor &)result);
80412   return jresult;
80413 }
80414
80415
80416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
80417   void * jresult ;
80418   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80419   Dali::Actor arg2 ;
80420   Dali::Actor *argp2 ;
80421   Dali::Actor result;
80422
80423   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80424   argp2 = (Dali::Actor *)jarg2;
80425   if (!argp2) {
80426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80427     return 0;
80428   }
80429   arg2 = *argp2;
80430   {
80431     try {
80432       result = (arg1)->GetFocusGroup(arg2);
80433     } catch (std::out_of_range& e) {
80434       {
80435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80436       };
80437     } catch (std::exception& e) {
80438       {
80439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80440       };
80441     } catch (...) {
80442       {
80443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80444       };
80445     }
80446   }
80447   jresult = new Dali::Actor((const Dali::Actor &)result);
80448   return jresult;
80449 }
80450
80451
80452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
80453   void * jresult ;
80454   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80455   Dali::Vector2 result;
80456
80457   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80458   {
80459     try {
80460       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
80461     } catch (std::out_of_range& e) {
80462       {
80463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80464       };
80465     } catch (std::exception& e) {
80466       {
80467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80468       };
80469     } catch (...) {
80470       {
80471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80472       };
80473     }
80474   }
80475   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80476   return jresult;
80477 }
80478
80479
80480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
80481   void * jresult ;
80482   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80483   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
80484
80485   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80486   {
80487     try {
80488       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
80489     } catch (std::out_of_range& e) {
80490       {
80491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80492       };
80493     } catch (std::exception& e) {
80494       {
80495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80496       };
80497     } catch (...) {
80498       {
80499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80500       };
80501     }
80502   }
80503   jresult = (void *)result;
80504   return jresult;
80505 }
80506
80507
80508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
80509   void * jresult ;
80510   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80511   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
80512
80513   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80514   {
80515     try {
80516       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
80517     } catch (std::out_of_range& e) {
80518       {
80519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80520       };
80521     } catch (std::exception& e) {
80522       {
80523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80524       };
80525     } catch (...) {
80526       {
80527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80528       };
80529     }
80530   }
80531   jresult = (void *)result;
80532   return jresult;
80533 }
80534
80535
80536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
80537   void * jresult ;
80538   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80539   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
80540
80541   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80542   {
80543     try {
80544       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
80545     } catch (std::out_of_range& e) {
80546       {
80547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80548       };
80549     } catch (std::exception& e) {
80550       {
80551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80552       };
80553     } catch (...) {
80554       {
80555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80556       };
80557     }
80558   }
80559   jresult = (void *)result;
80560   return jresult;
80561 }
80562
80563
80564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
80565   void * jresult ;
80566   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80567   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80568
80569   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80570   {
80571     try {
80572       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
80573     } catch (std::out_of_range& e) {
80574       {
80575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80576       };
80577     } catch (std::exception& e) {
80578       {
80579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80580       };
80581     } catch (...) {
80582       {
80583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80584       };
80585     }
80586   }
80587   jresult = (void *)result;
80588   return jresult;
80589 }
80590
80591
80592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
80593   void * jresult ;
80594   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80595   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80596
80597   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80598   {
80599     try {
80600       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
80601     } catch (std::out_of_range& e) {
80602       {
80603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80604       };
80605     } catch (std::exception& e) {
80606       {
80607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80608       };
80609     } catch (...) {
80610       {
80611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80612       };
80613     }
80614   }
80615   jresult = (void *)result;
80616   return jresult;
80617 }
80618
80619
80620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
80621   void * jresult ;
80622   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80623   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80624
80625   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80626   {
80627     try {
80628       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
80629     } catch (std::out_of_range& e) {
80630       {
80631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80632       };
80633     } catch (std::exception& e) {
80634       {
80635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80636       };
80637     } catch (...) {
80638       {
80639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80640       };
80641     }
80642   }
80643   jresult = (void *)result;
80644   return jresult;
80645 }
80646
80647
80648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
80649   void * jresult ;
80650   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80651   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80652
80653   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80654   {
80655     try {
80656       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
80657     } catch (std::out_of_range& e) {
80658       {
80659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80660       };
80661     } catch (std::exception& e) {
80662       {
80663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80664       };
80665     } catch (...) {
80666       {
80667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80668       };
80669     }
80670   }
80671   jresult = (void *)result;
80672   return jresult;
80673 }
80674
80675
80676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
80677   void * jresult ;
80678   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80679   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80680
80681   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80682   {
80683     try {
80684       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
80685     } catch (std::out_of_range& e) {
80686       {
80687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80688       };
80689     } catch (std::exception& e) {
80690       {
80691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80692       };
80693     } catch (...) {
80694       {
80695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80696       };
80697     }
80698   }
80699   jresult = (void *)result;
80700   return jresult;
80701 }
80702
80703
80704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
80705   void * jresult ;
80706   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80707   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80708
80709   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80710   {
80711     try {
80712       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
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 = (void *)result;
80728   return jresult;
80729 }
80730
80731
80732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
80733   void * jresult ;
80734   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80735   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80736
80737   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80738   {
80739     try {
80740       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
80741     } catch (std::out_of_range& e) {
80742       {
80743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80744       };
80745     } catch (std::exception& e) {
80746       {
80747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80748       };
80749     } catch (...) {
80750       {
80751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80752       };
80753     }
80754   }
80755   jresult = (void *)result;
80756   return jresult;
80757 }
80758
80759
80760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
80761   void * jresult ;
80762   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80763   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80764
80765   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80766   {
80767     try {
80768       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
80769     } catch (std::out_of_range& e) {
80770       {
80771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80772       };
80773     } catch (std::exception& e) {
80774       {
80775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80776       };
80777     } catch (...) {
80778       {
80779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80780       };
80781     }
80782   }
80783   jresult = (void *)result;
80784   return jresult;
80785 }
80786
80787
80788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
80789   void * jresult ;
80790   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80791   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80792
80793   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80794   {
80795     try {
80796       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
80797     } catch (std::out_of_range& e) {
80798       {
80799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80800       };
80801     } catch (std::exception& e) {
80802       {
80803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80804       };
80805     } catch (...) {
80806       {
80807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80808       };
80809     }
80810   }
80811   jresult = (void *)result;
80812   return jresult;
80813 }
80814
80815
80816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
80817   void * jresult ;
80818   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80819   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80820
80821   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80822   {
80823     try {
80824       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
80825     } catch (std::out_of_range& e) {
80826       {
80827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80828       };
80829     } catch (std::exception& e) {
80830       {
80831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80832       };
80833     } catch (...) {
80834       {
80835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80836       };
80837     }
80838   }
80839   jresult = (void *)result;
80840   return jresult;
80841 }
80842
80843
80844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
80845   void * jresult ;
80846   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80847   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80848
80849   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80850   {
80851     try {
80852       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
80853     } catch (std::out_of_range& e) {
80854       {
80855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80856       };
80857     } catch (std::exception& e) {
80858       {
80859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80860       };
80861     } catch (...) {
80862       {
80863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80864       };
80865     }
80866   }
80867   jresult = (void *)result;
80868   return jresult;
80869 }
80870
80871
80872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
80873   void * jresult ;
80874   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80875   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80876
80877   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80878   {
80879     try {
80880       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
80881     } catch (std::out_of_range& e) {
80882       {
80883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80884       };
80885     } catch (std::exception& e) {
80886       {
80887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80888       };
80889     } catch (...) {
80890       {
80891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80892       };
80893     }
80894   }
80895   jresult = (void *)result;
80896   return jresult;
80897 }
80898
80899
80900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
80901   void * jresult ;
80902   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80903   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80904
80905   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80906   {
80907     try {
80908       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
80909     } catch (std::out_of_range& e) {
80910       {
80911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80912       };
80913     } catch (std::exception& e) {
80914       {
80915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80916       };
80917     } catch (...) {
80918       {
80919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80920       };
80921     }
80922   }
80923   jresult = (void *)result;
80924   return jresult;
80925 }
80926
80927
80928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
80929   void * jresult ;
80930   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80931   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80932
80933   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80934   {
80935     try {
80936       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
80937     } catch (std::out_of_range& e) {
80938       {
80939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80940       };
80941     } catch (std::exception& e) {
80942       {
80943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80944       };
80945     } catch (...) {
80946       {
80947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80948       };
80949     }
80950   }
80951   jresult = (void *)result;
80952   return jresult;
80953 }
80954
80955
80956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
80957   void * jresult ;
80958   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80959   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80960
80961   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80962   {
80963     try {
80964       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
80965     } catch (std::out_of_range& e) {
80966       {
80967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80968       };
80969     } catch (std::exception& e) {
80970       {
80971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80972       };
80973     } catch (...) {
80974       {
80975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80976       };
80977     }
80978   }
80979   jresult = (void *)result;
80980   return jresult;
80981 }
80982
80983
80984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
80985   void * jresult ;
80986   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80987   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80988
80989   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80990   {
80991     try {
80992       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
80993     } catch (std::out_of_range& e) {
80994       {
80995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80996       };
80997     } catch (std::exception& e) {
80998       {
80999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81000       };
81001     } catch (...) {
81002       {
81003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81004       };
81005     }
81006   }
81007   jresult = (void *)result;
81008   return jresult;
81009 }
81010
81011
81012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
81013   void * jresult ;
81014   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81015   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81016
81017   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81018   {
81019     try {
81020       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
81021     } catch (std::out_of_range& e) {
81022       {
81023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81024       };
81025     } catch (std::exception& e) {
81026       {
81027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81028       };
81029     } catch (...) {
81030       {
81031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81032       };
81033     }
81034   }
81035   jresult = (void *)result;
81036   return jresult;
81037 }
81038
81039
81040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
81041   void * jresult ;
81042   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81043   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81044
81045   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81046   {
81047     try {
81048       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
81049     } catch (std::out_of_range& e) {
81050       {
81051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81052       };
81053     } catch (std::exception& e) {
81054       {
81055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81056       };
81057     } catch (...) {
81058       {
81059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81060       };
81061     }
81062   }
81063   jresult = (void *)result;
81064   return jresult;
81065 }
81066
81067
81068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
81069   void * jresult ;
81070   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81071   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81072
81073   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81074   {
81075     try {
81076       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
81077     } catch (std::out_of_range& e) {
81078       {
81079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81080       };
81081     } catch (std::exception& e) {
81082       {
81083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81084       };
81085     } catch (...) {
81086       {
81087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81088       };
81089     }
81090   }
81091   jresult = (void *)result;
81092   return jresult;
81093 }
81094
81095
81096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
81097   void * jresult ;
81098   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81099   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81100
81101   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81102   {
81103     try {
81104       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
81105     } catch (std::out_of_range& e) {
81106       {
81107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81108       };
81109     } catch (std::exception& e) {
81110       {
81111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81112       };
81113     } catch (...) {
81114       {
81115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81116       };
81117     }
81118   }
81119   jresult = (void *)result;
81120   return jresult;
81121 }
81122
81123
81124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
81125   void * jresult ;
81126   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81127   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81128
81129   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81130   {
81131     try {
81132       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
81133     } catch (std::out_of_range& e) {
81134       {
81135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81136       };
81137     } catch (std::exception& e) {
81138       {
81139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81140       };
81141     } catch (...) {
81142       {
81143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81144       };
81145     }
81146   }
81147   jresult = (void *)result;
81148   return jresult;
81149 }
81150
81151
81152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
81153   void * jresult ;
81154   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81155   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81156
81157   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81158   {
81159     try {
81160       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
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 = (void *)result;
81176   return jresult;
81177 }
81178
81179
81180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
81181   void * jresult ;
81182   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81183   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81184
81185   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81186   {
81187     try {
81188       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
81189     } catch (std::out_of_range& e) {
81190       {
81191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81192       };
81193     } catch (std::exception& e) {
81194       {
81195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81196       };
81197     } catch (...) {
81198       {
81199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81200       };
81201     }
81202   }
81203   jresult = (void *)result;
81204   return jresult;
81205 }
81206
81207
81208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
81209   void * jresult ;
81210   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81211   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81212
81213   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81214   {
81215     try {
81216       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
81217     } catch (std::out_of_range& e) {
81218       {
81219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81220       };
81221     } catch (std::exception& e) {
81222       {
81223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81224       };
81225     } catch (...) {
81226       {
81227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81228       };
81229     }
81230   }
81231   jresult = (void *)result;
81232   return jresult;
81233 }
81234
81235
81236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
81237   void * jresult ;
81238   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81239   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81240
81241   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81242   {
81243     try {
81244       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
81245     } catch (std::out_of_range& e) {
81246       {
81247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81248       };
81249     } catch (std::exception& e) {
81250       {
81251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81252       };
81253     } catch (...) {
81254       {
81255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81256       };
81257     }
81258   }
81259   jresult = (void *)result;
81260   return jresult;
81261 }
81262
81263
81264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
81265   void * jresult ;
81266   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81267   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81268
81269   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81270   {
81271     try {
81272       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
81273     } catch (std::out_of_range& e) {
81274       {
81275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81276       };
81277     } catch (std::exception& e) {
81278       {
81279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81280       };
81281     } catch (...) {
81282       {
81283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81284       };
81285     }
81286   }
81287   jresult = (void *)result;
81288   return jresult;
81289 }
81290
81291
81292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
81293   void * jresult ;
81294   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81295   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
81296
81297   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81298   {
81299     try {
81300       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
81301     } catch (std::out_of_range& e) {
81302       {
81303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81304       };
81305     } catch (std::exception& e) {
81306       {
81307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81308       };
81309     } catch (...) {
81310       {
81311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81312       };
81313     }
81314   }
81315   jresult = (void *)result;
81316   return jresult;
81317 }
81318
81319
81320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
81321   void * jresult ;
81322   Dali::Toolkit::StyleManager *result = 0 ;
81323
81324   {
81325     try {
81326       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
81327     } catch (std::out_of_range& e) {
81328       {
81329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81330       };
81331     } catch (std::exception& e) {
81332       {
81333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81334       };
81335     } catch (...) {
81336       {
81337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81338       };
81339     }
81340   }
81341   jresult = (void *)result;
81342   return jresult;
81343 }
81344
81345
81346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
81347   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81348
81349   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81350   {
81351     try {
81352       delete arg1;
81353     } catch (std::out_of_range& e) {
81354       {
81355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81356       };
81357     } catch (std::exception& e) {
81358       {
81359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81360       };
81361     } catch (...) {
81362       {
81363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81364       };
81365     }
81366   }
81367 }
81368
81369
81370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
81371   void * jresult ;
81372   Dali::Toolkit::StyleManager result;
81373
81374   {
81375     try {
81376       result = Dali::Toolkit::StyleManager::Get();
81377     } catch (std::out_of_range& e) {
81378       {
81379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81380       };
81381     } catch (std::exception& e) {
81382       {
81383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81384       };
81385     } catch (...) {
81386       {
81387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81388       };
81389     }
81390   }
81391   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
81392   return jresult;
81393 }
81394
81395
81396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
81397   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81398   std::string *arg2 = 0 ;
81399
81400   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81401   if (!jarg2) {
81402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81403     return ;
81404   }
81405   std::string arg2_str(jarg2);
81406   arg2 = &arg2_str;
81407   {
81408     try {
81409       (arg1)->ApplyTheme((std::string const &)*arg2);
81410     } catch (std::out_of_range& e) {
81411       {
81412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81413       };
81414     } catch (std::exception& e) {
81415       {
81416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81417       };
81418     } catch (...) {
81419       {
81420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81421       };
81422     }
81423   }
81424
81425   //argout typemap for const std::string&
81426
81427 }
81428
81429
81430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
81431   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81432
81433   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81434   {
81435     try {
81436       (arg1)->ApplyDefaultTheme();
81437     } catch (std::out_of_range& e) {
81438       {
81439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81440       };
81441     } catch (std::exception& e) {
81442       {
81443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81444       };
81445     } catch (...) {
81446       {
81447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81448       };
81449     }
81450   }
81451 }
81452
81453
81454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
81455   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81456   std::string *arg2 = 0 ;
81457   Dali::Property::Value *arg3 = 0 ;
81458
81459   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81460   if (!jarg2) {
81461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81462     return ;
81463   }
81464   std::string arg2_str(jarg2);
81465   arg2 = &arg2_str;
81466   arg3 = (Dali::Property::Value *)jarg3;
81467   if (!arg3) {
81468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
81469     return ;
81470   }
81471   {
81472     try {
81473       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
81474     } catch (std::out_of_range& e) {
81475       {
81476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81477       };
81478     } catch (std::exception& e) {
81479       {
81480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81481       };
81482     } catch (...) {
81483       {
81484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81485       };
81486     }
81487   }
81488
81489   //argout typemap for const std::string&
81490
81491 }
81492
81493
81494 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
81495   unsigned int jresult ;
81496   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81497   std::string *arg2 = 0 ;
81498   Dali::Property::Value *arg3 = 0 ;
81499   bool result;
81500
81501   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81502   if (!jarg2) {
81503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81504     return 0;
81505   }
81506   std::string arg2_str(jarg2);
81507   arg2 = &arg2_str;
81508   arg3 = (Dali::Property::Value *)jarg3;
81509   if (!arg3) {
81510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
81511     return 0;
81512   }
81513   {
81514     try {
81515       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
81516     } catch (std::out_of_range& e) {
81517       {
81518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81519       };
81520     } catch (std::exception& e) {
81521       {
81522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81523       };
81524     } catch (...) {
81525       {
81526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81527       };
81528     }
81529   }
81530   jresult = result;
81531
81532   //argout typemap for const std::string&
81533
81534   return jresult;
81535 }
81536
81537
81538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
81539   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81540   Dali::Toolkit::Control arg2 ;
81541   std::string *arg3 = 0 ;
81542   std::string *arg4 = 0 ;
81543   Dali::Toolkit::Control *argp2 ;
81544
81545   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81546   argp2 = (Dali::Toolkit::Control *)jarg2;
81547   if (!argp2) {
81548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
81549     return ;
81550   }
81551   arg2 = *argp2;
81552   if (!jarg3) {
81553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81554     return ;
81555   }
81556   std::string arg3_str(jarg3);
81557   arg3 = &arg3_str;
81558   if (!jarg4) {
81559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81560     return ;
81561   }
81562   std::string arg4_str(jarg4);
81563   arg4 = &arg4_str;
81564   {
81565     try {
81566       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
81567     } catch (std::out_of_range& e) {
81568       {
81569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81570       };
81571     } catch (std::exception& e) {
81572       {
81573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81574       };
81575     } catch (...) {
81576       {
81577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81578       };
81579     }
81580   }
81581
81582   //argout typemap for const std::string&
81583
81584
81585   //argout typemap for const std::string&
81586
81587 }
81588
81589
81590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
81591   void * jresult ;
81592   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81593   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
81594
81595   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81596   {
81597     try {
81598       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
81599     } catch (std::out_of_range& e) {
81600       {
81601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81602       };
81603     } catch (std::exception& e) {
81604       {
81605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81606       };
81607     } catch (...) {
81608       {
81609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81610       };
81611     }
81612   }
81613   jresult = (void *)result;
81614   return jresult;
81615 }
81616
81617
81618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
81619   int jresult ;
81620   int result;
81621
81622   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
81623   jresult = (int)result;
81624   return jresult;
81625 }
81626
81627
81628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
81629   int jresult ;
81630   int result;
81631
81632   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
81633   jresult = (int)result;
81634   return jresult;
81635 }
81636
81637
81638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
81639   int jresult ;
81640   int result;
81641
81642   result = (int)Dali::Toolkit::Slider::Property::VALUE;
81643   jresult = (int)result;
81644   return jresult;
81645 }
81646
81647
81648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
81649   int jresult ;
81650   int result;
81651
81652   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
81653   jresult = (int)result;
81654   return jresult;
81655 }
81656
81657
81658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
81659   int jresult ;
81660   int result;
81661
81662   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
81663   jresult = (int)result;
81664   return jresult;
81665 }
81666
81667
81668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
81669   int jresult ;
81670   int result;
81671
81672   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
81673   jresult = (int)result;
81674   return jresult;
81675 }
81676
81677
81678 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
81679   int jresult ;
81680   int result;
81681
81682   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
81683   jresult = (int)result;
81684   return jresult;
81685 }
81686
81687
81688 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
81689   int jresult ;
81690   int result;
81691
81692   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
81693   jresult = (int)result;
81694   return jresult;
81695 }
81696
81697
81698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
81699   int jresult ;
81700   int result;
81701
81702   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
81703   jresult = (int)result;
81704   return jresult;
81705 }
81706
81707
81708 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
81709   int jresult ;
81710   int result;
81711
81712   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
81713   jresult = (int)result;
81714   return jresult;
81715 }
81716
81717
81718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
81719   int jresult ;
81720   int result;
81721
81722   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
81723   jresult = (int)result;
81724   return jresult;
81725 }
81726
81727
81728 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
81729   int jresult ;
81730   int result;
81731
81732   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
81733   jresult = (int)result;
81734   return jresult;
81735 }
81736
81737
81738 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
81739   int jresult ;
81740   int result;
81741
81742   result = (int)Dali::Toolkit::Slider::Property::MARKS;
81743   jresult = (int)result;
81744   return jresult;
81745 }
81746
81747
81748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
81749   int jresult ;
81750   int result;
81751
81752   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
81753   jresult = (int)result;
81754   return jresult;
81755 }
81756
81757
81758 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
81759   int jresult ;
81760   int result;
81761
81762   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
81763   jresult = (int)result;
81764   return jresult;
81765 }
81766
81767
81768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
81769   void * jresult ;
81770   Dali::Toolkit::Slider::Property *result = 0 ;
81771
81772   {
81773     try {
81774       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
81775     } catch (std::out_of_range& e) {
81776       {
81777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81778       };
81779     } catch (std::exception& e) {
81780       {
81781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81782       };
81783     } catch (...) {
81784       {
81785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81786       };
81787     }
81788   }
81789   jresult = (void *)result;
81790   return jresult;
81791 }
81792
81793
81794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
81795   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
81796
81797   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
81798   {
81799     try {
81800       delete arg1;
81801     } catch (std::out_of_range& e) {
81802       {
81803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81804       };
81805     } catch (std::exception& e) {
81806       {
81807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81808       };
81809     } catch (...) {
81810       {
81811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81812       };
81813     }
81814   }
81815 }
81816
81817
81818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
81819   void * jresult ;
81820   Dali::Toolkit::Slider result;
81821
81822   {
81823     try {
81824       result = Dali::Toolkit::Slider::New();
81825     } catch (std::out_of_range& e) {
81826       {
81827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81828       };
81829     } catch (std::exception& e) {
81830       {
81831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81832       };
81833     } catch (...) {
81834       {
81835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81836       };
81837     }
81838   }
81839   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81840   return jresult;
81841 }
81842
81843
81844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
81845   void * jresult ;
81846   Dali::Toolkit::Slider *result = 0 ;
81847
81848   {
81849     try {
81850       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
81851     } catch (std::out_of_range& e) {
81852       {
81853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81854       };
81855     } catch (std::exception& e) {
81856       {
81857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81858       };
81859     } catch (...) {
81860       {
81861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81862       };
81863     }
81864   }
81865   jresult = (void *)result;
81866   return jresult;
81867 }
81868
81869
81870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
81871   void * jresult ;
81872   Dali::Toolkit::Slider *arg1 = 0 ;
81873   Dali::Toolkit::Slider *result = 0 ;
81874
81875   arg1 = (Dali::Toolkit::Slider *)jarg1;
81876   if (!arg1) {
81877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
81878     return 0;
81879   }
81880   {
81881     try {
81882       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
81883     } catch (std::out_of_range& e) {
81884       {
81885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81886       };
81887     } catch (std::exception& e) {
81888       {
81889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81890       };
81891     } catch (...) {
81892       {
81893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81894       };
81895     }
81896   }
81897   jresult = (void *)result;
81898   return jresult;
81899 }
81900
81901
81902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
81903   void * jresult ;
81904   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81905   Dali::Toolkit::Slider *arg2 = 0 ;
81906   Dali::Toolkit::Slider *result = 0 ;
81907
81908   arg1 = (Dali::Toolkit::Slider *)jarg1;
81909   arg2 = (Dali::Toolkit::Slider *)jarg2;
81910   if (!arg2) {
81911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
81912     return 0;
81913   }
81914   {
81915     try {
81916       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
81917     } catch (std::out_of_range& e) {
81918       {
81919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81920       };
81921     } catch (std::exception& e) {
81922       {
81923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81924       };
81925     } catch (...) {
81926       {
81927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81928       };
81929     }
81930   }
81931   jresult = (void *)result;
81932   return jresult;
81933 }
81934
81935
81936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
81937   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81938
81939   arg1 = (Dali::Toolkit::Slider *)jarg1;
81940   {
81941     try {
81942       delete arg1;
81943     } catch (std::out_of_range& e) {
81944       {
81945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81946       };
81947     } catch (std::exception& e) {
81948       {
81949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81950       };
81951     } catch (...) {
81952       {
81953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81954       };
81955     }
81956   }
81957 }
81958
81959
81960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
81961   void * jresult ;
81962   Dali::BaseHandle arg1 ;
81963   Dali::BaseHandle *argp1 ;
81964   Dali::Toolkit::Slider result;
81965
81966   argp1 = (Dali::BaseHandle *)jarg1;
81967   if (!argp1) {
81968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81969     return 0;
81970   }
81971   arg1 = *argp1;
81972   {
81973     try {
81974       result = Dali::Toolkit::Slider::DownCast(arg1);
81975     } catch (std::out_of_range& e) {
81976       {
81977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81978       };
81979     } catch (std::exception& e) {
81980       {
81981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81982       };
81983     } catch (...) {
81984       {
81985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81986       };
81987     }
81988   }
81989   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81990   return jresult;
81991 }
81992
81993
81994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
81995   void * jresult ;
81996   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81997   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
81998
81999   arg1 = (Dali::Toolkit::Slider *)jarg1;
82000   {
82001     try {
82002       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
82003     } catch (std::out_of_range& e) {
82004       {
82005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82006       };
82007     } catch (std::exception& e) {
82008       {
82009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82010       };
82011     } catch (...) {
82012       {
82013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82014       };
82015     }
82016   }
82017   jresult = (void *)result;
82018   return jresult;
82019 }
82020
82021
82022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
82023   void * jresult ;
82024   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82025   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
82026
82027   arg1 = (Dali::Toolkit::Slider *)jarg1;
82028   {
82029     try {
82030       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
82031     } catch (std::out_of_range& e) {
82032       {
82033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82034       };
82035     } catch (std::exception& e) {
82036       {
82037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82038       };
82039     } catch (...) {
82040       {
82041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82042       };
82043     }
82044   }
82045   jresult = (void *)result;
82046   return jresult;
82047 }
82048
82049
82050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
82051   void * jresult ;
82052   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82053   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
82054
82055   arg1 = (Dali::Toolkit::Slider *)jarg1;
82056   {
82057     try {
82058       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
82059     } catch (std::out_of_range& e) {
82060       {
82061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82062       };
82063     } catch (std::exception& e) {
82064       {
82065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82066       };
82067     } catch (...) {
82068       {
82069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82070       };
82071     }
82072   }
82073   jresult = (void *)result;
82074   return jresult;
82075 }
82076
82077
82078 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
82079   int jresult ;
82080   int result;
82081
82082   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
82083   jresult = (int)result;
82084   return jresult;
82085 }
82086
82087
82088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
82089   int jresult ;
82090   int result;
82091
82092   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
82093   jresult = (int)result;
82094   return jresult;
82095 }
82096
82097
82098 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
82099   int jresult ;
82100   int result;
82101
82102   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
82103   jresult = (int)result;
82104   return jresult;
82105 }
82106
82107
82108 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
82109   int jresult ;
82110   int result;
82111
82112   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
82113   jresult = (int)result;
82114   return jresult;
82115 }
82116
82117
82118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
82119   void * jresult ;
82120   Dali::Toolkit::VideoView::Property *result = 0 ;
82121
82122   {
82123     try {
82124       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
82125     } catch (std::out_of_range& e) {
82126       {
82127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82128       };
82129     } catch (std::exception& e) {
82130       {
82131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82132       };
82133     } catch (...) {
82134       {
82135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82136       };
82137     }
82138   }
82139   jresult = (void *)result;
82140   return jresult;
82141 }
82142
82143
82144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
82145   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
82146
82147   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
82148   {
82149     try {
82150       delete arg1;
82151     } catch (std::out_of_range& e) {
82152       {
82153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82154       };
82155     } catch (std::exception& e) {
82156       {
82157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82158       };
82159     } catch (...) {
82160       {
82161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82162       };
82163     }
82164   }
82165 }
82166
82167
82168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
82169   void * jresult ;
82170   Dali::Toolkit::VideoView result;
82171
82172   {
82173     try {
82174       result = Dali::Toolkit::VideoView::New();
82175     } catch (std::out_of_range& e) {
82176       {
82177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82178       };
82179     } catch (std::exception& e) {
82180       {
82181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82182       };
82183     } catch (...) {
82184       {
82185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82186       };
82187     }
82188   }
82189   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82190   return jresult;
82191 }
82192
82193
82194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
82195   void * jresult ;
82196   std::string *arg1 = 0 ;
82197   Dali::Toolkit::VideoView result;
82198
82199   if (!jarg1) {
82200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
82201     return 0;
82202   }
82203   std::string arg1_str(jarg1);
82204   arg1 = &arg1_str;
82205   {
82206     try {
82207       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
82208     } catch (std::out_of_range& e) {
82209       {
82210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82211       };
82212     } catch (std::exception& e) {
82213       {
82214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82215       };
82216     } catch (...) {
82217       {
82218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82219       };
82220     }
82221   }
82222   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82223
82224   //argout typemap for const std::string&
82225
82226   return jresult;
82227 }
82228
82229
82230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
82231   void * jresult ;
82232   Dali::Toolkit::VideoView *result = 0 ;
82233
82234   {
82235     try {
82236       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
82237     } catch (std::out_of_range& e) {
82238       {
82239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82240       };
82241     } catch (std::exception& e) {
82242       {
82243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82244       };
82245     } catch (...) {
82246       {
82247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82248       };
82249     }
82250   }
82251   jresult = (void *)result;
82252   return jresult;
82253 }
82254
82255
82256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
82257   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82258
82259   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82260   {
82261     try {
82262       delete arg1;
82263     } catch (std::out_of_range& e) {
82264       {
82265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82266       };
82267     } catch (std::exception& e) {
82268       {
82269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82270       };
82271     } catch (...) {
82272       {
82273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82274       };
82275     }
82276   }
82277 }
82278
82279
82280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
82281   void * jresult ;
82282   Dali::Toolkit::VideoView *arg1 = 0 ;
82283   Dali::Toolkit::VideoView *result = 0 ;
82284
82285   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82286   if (!arg1) {
82287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82288     return 0;
82289   }
82290   {
82291     try {
82292       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
82293     } catch (std::out_of_range& e) {
82294       {
82295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82296       };
82297     } catch (std::exception& e) {
82298       {
82299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82300       };
82301     } catch (...) {
82302       {
82303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82304       };
82305     }
82306   }
82307   jresult = (void *)result;
82308   return jresult;
82309 }
82310
82311
82312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
82313   void * jresult ;
82314   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82315   Dali::Toolkit::VideoView *arg2 = 0 ;
82316   Dali::Toolkit::VideoView *result = 0 ;
82317
82318   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82319   arg2 = (Dali::Toolkit::VideoView *)jarg2;
82320   if (!arg2) {
82321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82322     return 0;
82323   }
82324   {
82325     try {
82326       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
82327     } catch (std::out_of_range& e) {
82328       {
82329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82330       };
82331     } catch (std::exception& e) {
82332       {
82333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82334       };
82335     } catch (...) {
82336       {
82337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82338       };
82339     }
82340   }
82341   jresult = (void *)result;
82342   return jresult;
82343 }
82344
82345
82346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
82347   void * jresult ;
82348   Dali::BaseHandle arg1 ;
82349   Dali::BaseHandle *argp1 ;
82350   Dali::Toolkit::VideoView result;
82351
82352   argp1 = (Dali::BaseHandle *)jarg1;
82353   if (!argp1) {
82354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82355     return 0;
82356   }
82357   arg1 = *argp1;
82358   {
82359     try {
82360       result = Dali::Toolkit::VideoView::DownCast(arg1);
82361     } catch (std::out_of_range& e) {
82362       {
82363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82364       };
82365     } catch (std::exception& e) {
82366       {
82367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82368       };
82369     } catch (...) {
82370       {
82371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82372       };
82373     }
82374   }
82375   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82376   return jresult;
82377 }
82378
82379
82380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
82381   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82382
82383   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82384   {
82385     try {
82386       (arg1)->Play();
82387     } catch (std::out_of_range& e) {
82388       {
82389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82390       };
82391     } catch (std::exception& e) {
82392       {
82393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82394       };
82395     } catch (...) {
82396       {
82397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82398       };
82399     }
82400   }
82401 }
82402
82403
82404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
82405   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82406
82407   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82408   {
82409     try {
82410       (arg1)->Pause();
82411     } catch (std::out_of_range& e) {
82412       {
82413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82414       };
82415     } catch (std::exception& e) {
82416       {
82417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82418       };
82419     } catch (...) {
82420       {
82421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82422       };
82423     }
82424   }
82425 }
82426
82427
82428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
82429   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82430
82431   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82432   {
82433     try {
82434       (arg1)->Stop();
82435     } catch (std::out_of_range& e) {
82436       {
82437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82438       };
82439     } catch (std::exception& e) {
82440       {
82441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82442       };
82443     } catch (...) {
82444       {
82445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82446       };
82447     }
82448   }
82449 }
82450
82451
82452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
82453   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82454   int arg2 ;
82455
82456   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82457   arg2 = (int)jarg2;
82458   {
82459     try {
82460       (arg1)->Forward(arg2);
82461     } catch (std::out_of_range& e) {
82462       {
82463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82464       };
82465     } catch (std::exception& e) {
82466       {
82467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82468       };
82469     } catch (...) {
82470       {
82471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82472       };
82473     }
82474   }
82475 }
82476
82477
82478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
82479   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82480   int arg2 ;
82481
82482   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82483   arg2 = (int)jarg2;
82484   {
82485     try {
82486       (arg1)->Backward(arg2);
82487     } catch (std::out_of_range& e) {
82488       {
82489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82490       };
82491     } catch (std::exception& e) {
82492       {
82493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82494       };
82495     } catch (...) {
82496       {
82497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82498       };
82499     }
82500   }
82501 }
82502
82503
82504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
82505   void * jresult ;
82506   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82507   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
82508
82509   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82510   {
82511     try {
82512       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
82513     } catch (std::out_of_range& e) {
82514       {
82515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82516       };
82517     } catch (std::exception& e) {
82518       {
82519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82520       };
82521     } catch (...) {
82522       {
82523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82524       };
82525     }
82526   }
82527   jresult = (void *)result;
82528   return jresult;
82529 }
82530
82531
82532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
82533   int jresult ;
82534   int result;
82535
82536   result = (int)Dali::Toolkit::Popup::Property::TITLE;
82537   jresult = (int)result;
82538   return jresult;
82539 }
82540
82541
82542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
82543   int jresult ;
82544   int result;
82545
82546   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
82547   jresult = (int)result;
82548   return jresult;
82549 }
82550
82551
82552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
82553   int jresult ;
82554   int result;
82555
82556   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
82557   jresult = (int)result;
82558   return jresult;
82559 }
82560
82561
82562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
82563   int jresult ;
82564   int result;
82565
82566   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
82567   jresult = (int)result;
82568   return jresult;
82569 }
82570
82571
82572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
82573   int jresult ;
82574   int result;
82575
82576   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
82577   jresult = (int)result;
82578   return jresult;
82579 }
82580
82581
82582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
82583   int jresult ;
82584   int result;
82585
82586   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
82587   jresult = (int)result;
82588   return jresult;
82589 }
82590
82591
82592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
82593   int jresult ;
82594   int result;
82595
82596   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
82597   jresult = (int)result;
82598   return jresult;
82599 }
82600
82601
82602 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
82603   int jresult ;
82604   int result;
82605
82606   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
82607   jresult = (int)result;
82608   return jresult;
82609 }
82610
82611
82612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
82613   int jresult ;
82614   int result;
82615
82616   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
82617   jresult = (int)result;
82618   return jresult;
82619 }
82620
82621
82622 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
82623   int jresult ;
82624   int result;
82625
82626   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
82627   jresult = (int)result;
82628   return jresult;
82629 }
82630
82631
82632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
82633   int jresult ;
82634   int result;
82635
82636   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
82637   jresult = (int)result;
82638   return jresult;
82639 }
82640
82641
82642 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
82643   int jresult ;
82644   int result;
82645
82646   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
82647   jresult = (int)result;
82648   return jresult;
82649 }
82650
82651
82652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
82653   int jresult ;
82654   int result;
82655
82656   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
82657   jresult = (int)result;
82658   return jresult;
82659 }
82660
82661
82662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
82663   int jresult ;
82664   int result;
82665
82666   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
82667   jresult = (int)result;
82668   return jresult;
82669 }
82670
82671
82672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
82673   int jresult ;
82674   int result;
82675
82676   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
82677   jresult = (int)result;
82678   return jresult;
82679 }
82680
82681
82682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
82683   int jresult ;
82684   int result;
82685
82686   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
82687   jresult = (int)result;
82688   return jresult;
82689 }
82690
82691
82692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
82693   int jresult ;
82694   int result;
82695
82696   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
82697   jresult = (int)result;
82698   return jresult;
82699 }
82700
82701
82702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
82703   int jresult ;
82704   int result;
82705
82706   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
82707   jresult = (int)result;
82708   return jresult;
82709 }
82710
82711
82712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
82713   int jresult ;
82714   int result;
82715
82716   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
82717   jresult = (int)result;
82718   return jresult;
82719 }
82720
82721
82722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
82723   int jresult ;
82724   int result;
82725
82726   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
82727   jresult = (int)result;
82728   return jresult;
82729 }
82730
82731
82732 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
82733   int jresult ;
82734   int result;
82735
82736   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
82737   jresult = (int)result;
82738   return jresult;
82739 }
82740
82741
82742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
82743   void * jresult ;
82744   Dali::Toolkit::Popup::Property *result = 0 ;
82745
82746   {
82747     try {
82748       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
82749     } catch (std::out_of_range& e) {
82750       {
82751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82752       };
82753     } catch (std::exception& e) {
82754       {
82755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82756       };
82757     } catch (...) {
82758       {
82759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82760       };
82761     }
82762   }
82763   jresult = (void *)result;
82764   return jresult;
82765 }
82766
82767
82768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
82769   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
82770
82771   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
82772   {
82773     try {
82774       delete arg1;
82775     } catch (std::out_of_range& e) {
82776       {
82777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82778       };
82779     } catch (std::exception& e) {
82780       {
82781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82782       };
82783     } catch (...) {
82784       {
82785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82786       };
82787     }
82788   }
82789 }
82790
82791
82792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
82793   void * jresult ;
82794   Dali::Toolkit::Popup *result = 0 ;
82795
82796   {
82797     try {
82798       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
82799     } catch (std::out_of_range& e) {
82800       {
82801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82802       };
82803     } catch (std::exception& e) {
82804       {
82805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82806       };
82807     } catch (...) {
82808       {
82809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82810       };
82811     }
82812   }
82813   jresult = (void *)result;
82814   return jresult;
82815 }
82816
82817
82818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
82819   void * jresult ;
82820   Dali::Toolkit::Popup result;
82821
82822   {
82823     try {
82824       result = Dali::Toolkit::Popup::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::Popup((const Dali::Toolkit::Popup &)result);
82840   return jresult;
82841 }
82842
82843
82844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
82845   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82846
82847   arg1 = (Dali::Toolkit::Popup *)jarg1;
82848   {
82849     try {
82850       delete arg1;
82851     } catch (std::out_of_range& e) {
82852       {
82853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82854       };
82855     } catch (std::exception& e) {
82856       {
82857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82858       };
82859     } catch (...) {
82860       {
82861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82862       };
82863     }
82864   }
82865 }
82866
82867
82868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
82869   void * jresult ;
82870   Dali::Toolkit::Popup *arg1 = 0 ;
82871   Dali::Toolkit::Popup *result = 0 ;
82872
82873   arg1 = (Dali::Toolkit::Popup *)jarg1;
82874   if (!arg1) {
82875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
82876     return 0;
82877   }
82878   {
82879     try {
82880       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
82881     } catch (std::out_of_range& e) {
82882       {
82883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82884       };
82885     } catch (std::exception& e) {
82886       {
82887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82888       };
82889     } catch (...) {
82890       {
82891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82892       };
82893     }
82894   }
82895   jresult = (void *)result;
82896   return jresult;
82897 }
82898
82899
82900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
82901   void * jresult ;
82902   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82903   Dali::Toolkit::Popup *arg2 = 0 ;
82904   Dali::Toolkit::Popup *result = 0 ;
82905
82906   arg1 = (Dali::Toolkit::Popup *)jarg1;
82907   arg2 = (Dali::Toolkit::Popup *)jarg2;
82908   if (!arg2) {
82909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
82910     return 0;
82911   }
82912   {
82913     try {
82914       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
82915     } catch (std::out_of_range& e) {
82916       {
82917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82918       };
82919     } catch (std::exception& e) {
82920       {
82921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82922       };
82923     } catch (...) {
82924       {
82925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82926       };
82927     }
82928   }
82929   jresult = (void *)result;
82930   return jresult;
82931 }
82932
82933
82934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
82935   void * jresult ;
82936   Dali::BaseHandle arg1 ;
82937   Dali::BaseHandle *argp1 ;
82938   Dali::Toolkit::Popup result;
82939
82940   argp1 = (Dali::BaseHandle *)jarg1;
82941   if (!argp1) {
82942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82943     return 0;
82944   }
82945   arg1 = *argp1;
82946   {
82947     try {
82948       result = Dali::Toolkit::Popup::DownCast(arg1);
82949     } catch (std::out_of_range& e) {
82950       {
82951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82952       };
82953     } catch (std::exception& e) {
82954       {
82955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82956       };
82957     } catch (...) {
82958       {
82959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82960       };
82961     }
82962   }
82963   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
82964   return jresult;
82965 }
82966
82967
82968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
82969   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82970   Dali::Actor arg2 ;
82971   Dali::Actor *argp2 ;
82972
82973   arg1 = (Dali::Toolkit::Popup *)jarg1;
82974   argp2 = (Dali::Actor *)jarg2;
82975   if (!argp2) {
82976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82977     return ;
82978   }
82979   arg2 = *argp2;
82980   {
82981     try {
82982       (arg1)->SetTitle(arg2);
82983     } catch (std::out_of_range& e) {
82984       {
82985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82986       };
82987     } catch (std::exception& e) {
82988       {
82989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82990       };
82991     } catch (...) {
82992       {
82993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82994       };
82995     }
82996   }
82997 }
82998
82999
83000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
83001   void * jresult ;
83002   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83003   Dali::Actor result;
83004
83005   arg1 = (Dali::Toolkit::Popup *)jarg1;
83006   {
83007     try {
83008       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
83009     } catch (std::out_of_range& e) {
83010       {
83011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83012       };
83013     } catch (std::exception& e) {
83014       {
83015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83016       };
83017     } catch (...) {
83018       {
83019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83020       };
83021     }
83022   }
83023   jresult = new Dali::Actor((const Dali::Actor &)result);
83024   return jresult;
83025 }
83026
83027
83028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
83029   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83030   Dali::Actor arg2 ;
83031   Dali::Actor *argp2 ;
83032
83033   arg1 = (Dali::Toolkit::Popup *)jarg1;
83034   argp2 = (Dali::Actor *)jarg2;
83035   if (!argp2) {
83036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83037     return ;
83038   }
83039   arg2 = *argp2;
83040   {
83041     try {
83042       (arg1)->SetContent(arg2);
83043     } catch (std::out_of_range& e) {
83044       {
83045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83046       };
83047     } catch (std::exception& e) {
83048       {
83049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83050       };
83051     } catch (...) {
83052       {
83053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83054       };
83055     }
83056   }
83057 }
83058
83059
83060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
83061   void * jresult ;
83062   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83063   Dali::Actor result;
83064
83065   arg1 = (Dali::Toolkit::Popup *)jarg1;
83066   {
83067     try {
83068       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
83069     } catch (std::out_of_range& e) {
83070       {
83071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83072       };
83073     } catch (std::exception& e) {
83074       {
83075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83076       };
83077     } catch (...) {
83078       {
83079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83080       };
83081     }
83082   }
83083   jresult = new Dali::Actor((const Dali::Actor &)result);
83084   return jresult;
83085 }
83086
83087
83088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
83089   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83090   Dali::Actor arg2 ;
83091   Dali::Actor *argp2 ;
83092
83093   arg1 = (Dali::Toolkit::Popup *)jarg1;
83094   argp2 = (Dali::Actor *)jarg2;
83095   if (!argp2) {
83096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83097     return ;
83098   }
83099   arg2 = *argp2;
83100   {
83101     try {
83102       (arg1)->SetFooter(arg2);
83103     } catch (std::out_of_range& e) {
83104       {
83105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83106       };
83107     } catch (std::exception& e) {
83108       {
83109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83110       };
83111     } catch (...) {
83112       {
83113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83114       };
83115     }
83116   }
83117 }
83118
83119
83120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
83121   void * jresult ;
83122   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83123   Dali::Actor result;
83124
83125   arg1 = (Dali::Toolkit::Popup *)jarg1;
83126   {
83127     try {
83128       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
83129     } catch (std::out_of_range& e) {
83130       {
83131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83132       };
83133     } catch (std::exception& e) {
83134       {
83135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83136       };
83137     } catch (...) {
83138       {
83139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83140       };
83141     }
83142   }
83143   jresult = new Dali::Actor((const Dali::Actor &)result);
83144   return jresult;
83145 }
83146
83147
83148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
83149   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83150   Dali::Toolkit::Popup::DisplayState arg2 ;
83151
83152   arg1 = (Dali::Toolkit::Popup *)jarg1;
83153   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
83154   {
83155     try {
83156       (arg1)->SetDisplayState(arg2);
83157     } catch (std::out_of_range& e) {
83158       {
83159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83160       };
83161     } catch (std::exception& e) {
83162       {
83163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83164       };
83165     } catch (...) {
83166       {
83167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83168       };
83169     }
83170   }
83171 }
83172
83173
83174 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
83175   int jresult ;
83176   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83177   Dali::Toolkit::Popup::DisplayState result;
83178
83179   arg1 = (Dali::Toolkit::Popup *)jarg1;
83180   {
83181     try {
83182       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
83183     } catch (std::out_of_range& e) {
83184       {
83185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83186       };
83187     } catch (std::exception& e) {
83188       {
83189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83190       };
83191     } catch (...) {
83192       {
83193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83194       };
83195     }
83196   }
83197   jresult = (int)result;
83198   return jresult;
83199 }
83200
83201
83202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
83203   void * jresult ;
83204   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83205   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
83206
83207   arg1 = (Dali::Toolkit::Popup *)jarg1;
83208   {
83209     try {
83210       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
83211     } catch (std::out_of_range& e) {
83212       {
83213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83214       };
83215     } catch (std::exception& e) {
83216       {
83217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83218       };
83219     } catch (...) {
83220       {
83221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83222       };
83223     }
83224   }
83225   jresult = (void *)result;
83226   return jresult;
83227 }
83228
83229
83230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
83231   void * jresult ;
83232   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83233   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83234
83235   arg1 = (Dali::Toolkit::Popup *)jarg1;
83236   {
83237     try {
83238       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
83239     } catch (std::out_of_range& e) {
83240       {
83241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83242       };
83243     } catch (std::exception& e) {
83244       {
83245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83246       };
83247     } catch (...) {
83248       {
83249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83250       };
83251     }
83252   }
83253   jresult = (void *)result;
83254   return jresult;
83255 }
83256
83257
83258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
83259   void * jresult ;
83260   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83261   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83262
83263   arg1 = (Dali::Toolkit::Popup *)jarg1;
83264   {
83265     try {
83266       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
83267     } catch (std::out_of_range& e) {
83268       {
83269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83270       };
83271     } catch (std::exception& e) {
83272       {
83273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83274       };
83275     } catch (...) {
83276       {
83277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83278       };
83279     }
83280   }
83281   jresult = (void *)result;
83282   return jresult;
83283 }
83284
83285
83286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
83287   void * jresult ;
83288   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83289   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83290
83291   arg1 = (Dali::Toolkit::Popup *)jarg1;
83292   {
83293     try {
83294       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
83295     } catch (std::out_of_range& e) {
83296       {
83297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83298       };
83299     } catch (std::exception& e) {
83300       {
83301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83302       };
83303     } catch (...) {
83304       {
83305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83306       };
83307     }
83308   }
83309   jresult = (void *)result;
83310   return jresult;
83311 }
83312
83313
83314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
83315   void * jresult ;
83316   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83317   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83318
83319   arg1 = (Dali::Toolkit::Popup *)jarg1;
83320   {
83321     try {
83322       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
83323     } catch (std::out_of_range& e) {
83324       {
83325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83326       };
83327     } catch (std::exception& e) {
83328       {
83329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83330       };
83331     } catch (...) {
83332       {
83333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83334       };
83335     }
83336   }
83337   jresult = (void *)result;
83338   return jresult;
83339 }
83340
83341
83342 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
83343   int jresult ;
83344   int result;
83345
83346   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
83347   jresult = (int)result;
83348   return jresult;
83349 }
83350
83351
83352 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
83353   int jresult ;
83354   int result;
83355
83356   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
83357   jresult = (int)result;
83358   return jresult;
83359 }
83360
83361
83362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
83363   int jresult ;
83364   int result;
83365
83366   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
83367   jresult = (int)result;
83368   return jresult;
83369 }
83370
83371
83372 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
83373   int jresult ;
83374   int result;
83375
83376   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
83377   jresult = (int)result;
83378   return jresult;
83379 }
83380
83381
83382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
83383   int jresult ;
83384   int result;
83385
83386   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
83387   jresult = (int)result;
83388   return jresult;
83389 }
83390
83391
83392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
83393   int jresult ;
83394   int result;
83395
83396   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
83397   jresult = (int)result;
83398   return jresult;
83399 }
83400
83401
83402 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
83403   int jresult ;
83404   int result;
83405
83406   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
83407   jresult = (int)result;
83408   return jresult;
83409 }
83410
83411
83412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
83413   int jresult ;
83414   int result;
83415
83416   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
83417   jresult = (int)result;
83418   return jresult;
83419 }
83420
83421
83422 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
83423   int jresult ;
83424   int result;
83425
83426   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
83427   jresult = (int)result;
83428   return jresult;
83429 }
83430
83431
83432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
83433   void * jresult ;
83434   Dali::Toolkit::ProgressBar::Property *result = 0 ;
83435
83436   {
83437     try {
83438       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
83439     } catch (std::out_of_range& e) {
83440       {
83441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83442       };
83443     } catch (std::exception& e) {
83444       {
83445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83446       };
83447     } catch (...) {
83448       {
83449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83450       };
83451     }
83452   }
83453   jresult = (void *)result;
83454   return jresult;
83455 }
83456
83457
83458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
83459   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
83460
83461   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
83462   {
83463     try {
83464       delete arg1;
83465     } catch (std::out_of_range& e) {
83466       {
83467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83468       };
83469     } catch (std::exception& e) {
83470       {
83471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83472       };
83473     } catch (...) {
83474       {
83475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83476       };
83477     }
83478   }
83479 }
83480
83481
83482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
83483   void * jresult ;
83484   Dali::Toolkit::ProgressBar result;
83485
83486   {
83487     try {
83488       result = Dali::Toolkit::ProgressBar::New();
83489     } catch (std::out_of_range& e) {
83490       {
83491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83492       };
83493     } catch (std::exception& e) {
83494       {
83495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83496       };
83497     } catch (...) {
83498       {
83499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83500       };
83501     }
83502   }
83503   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83504   return jresult;
83505 }
83506
83507
83508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
83509   void * jresult ;
83510   Dali::Toolkit::ProgressBar *result = 0 ;
83511
83512   {
83513     try {
83514       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
83515     } catch (std::out_of_range& e) {
83516       {
83517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83518       };
83519     } catch (std::exception& e) {
83520       {
83521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83522       };
83523     } catch (...) {
83524       {
83525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83526       };
83527     }
83528   }
83529   jresult = (void *)result;
83530   return jresult;
83531 }
83532
83533
83534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
83535   void * jresult ;
83536   Dali::Toolkit::ProgressBar *arg1 = 0 ;
83537   Dali::Toolkit::ProgressBar *result = 0 ;
83538
83539   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83540   if (!arg1) {
83541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83542     return 0;
83543   }
83544   {
83545     try {
83546       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
83547     } catch (std::out_of_range& e) {
83548       {
83549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83550       };
83551     } catch (std::exception& e) {
83552       {
83553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83554       };
83555     } catch (...) {
83556       {
83557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83558       };
83559     }
83560   }
83561   jresult = (void *)result;
83562   return jresult;
83563 }
83564
83565
83566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
83567   void * jresult ;
83568   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83569   Dali::Toolkit::ProgressBar *arg2 = 0 ;
83570   Dali::Toolkit::ProgressBar *result = 0 ;
83571
83572   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83573   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
83574   if (!arg2) {
83575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83576     return 0;
83577   }
83578   {
83579     try {
83580       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
83581     } catch (std::out_of_range& e) {
83582       {
83583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83584       };
83585     } catch (std::exception& e) {
83586       {
83587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83588       };
83589     } catch (...) {
83590       {
83591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83592       };
83593     }
83594   }
83595   jresult = (void *)result;
83596   return jresult;
83597 }
83598
83599
83600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
83601   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83602
83603   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83604   {
83605     try {
83606       delete arg1;
83607     } catch (std::out_of_range& e) {
83608       {
83609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83610       };
83611     } catch (std::exception& e) {
83612       {
83613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83614       };
83615     } catch (...) {
83616       {
83617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83618       };
83619     }
83620   }
83621 }
83622
83623
83624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
83625   void * jresult ;
83626   Dali::BaseHandle arg1 ;
83627   Dali::BaseHandle *argp1 ;
83628   Dali::Toolkit::ProgressBar result;
83629
83630   argp1 = (Dali::BaseHandle *)jarg1;
83631   if (!argp1) {
83632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83633     return 0;
83634   }
83635   arg1 = *argp1;
83636   {
83637     try {
83638       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
83639     } catch (std::out_of_range& e) {
83640       {
83641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83642       };
83643     } catch (std::exception& e) {
83644       {
83645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83646       };
83647     } catch (...) {
83648       {
83649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83650       };
83651     }
83652   }
83653   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83654   return jresult;
83655 }
83656
83657
83658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
83659   void * jresult ;
83660   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83661   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
83662
83663   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83664   {
83665     try {
83666       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
83667     } catch (std::out_of_range& e) {
83668       {
83669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83670       };
83671     } catch (std::exception& e) {
83672       {
83673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83674       };
83675     } catch (...) {
83676       {
83677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83678       };
83679     }
83680   }
83681   jresult = (void *)result;
83682   return jresult;
83683 }
83684
83685
83686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
83687   void * jresult ;
83688   Dali::Toolkit::GaussianBlurView *result = 0 ;
83689
83690   {
83691     try {
83692       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
83693     } catch (std::out_of_range& e) {
83694       {
83695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83696       };
83697     } catch (std::exception& e) {
83698       {
83699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83700       };
83701     } catch (...) {
83702       {
83703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83704       };
83705     }
83706   }
83707   jresult = (void *)result;
83708   return jresult;
83709 }
83710
83711
83712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
83713   void * jresult ;
83714   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
83715   Dali::Toolkit::GaussianBlurView *result = 0 ;
83716
83717   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83718   if (!arg1) {
83719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83720     return 0;
83721   }
83722   {
83723     try {
83724       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
83725     } catch (std::out_of_range& e) {
83726       {
83727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83728       };
83729     } catch (std::exception& e) {
83730       {
83731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83732       };
83733     } catch (...) {
83734       {
83735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83736       };
83737     }
83738   }
83739   jresult = (void *)result;
83740   return jresult;
83741 }
83742
83743
83744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
83745   void * jresult ;
83746   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83747   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
83748   Dali::Toolkit::GaussianBlurView *result = 0 ;
83749
83750   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83751   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
83752   if (!arg2) {
83753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83754     return 0;
83755   }
83756   {
83757     try {
83758       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
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_delete_GaussianBlurView(void * jarg1) {
83779   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83780
83781   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83782   {
83783     try {
83784       delete arg1;
83785     } catch (std::out_of_range& e) {
83786       {
83787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83788       };
83789     } catch (std::exception& e) {
83790       {
83791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83792       };
83793     } catch (...) {
83794       {
83795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83796       };
83797     }
83798   }
83799 }
83800
83801
83802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
83803   void * jresult ;
83804   Dali::BaseHandle arg1 ;
83805   Dali::BaseHandle *argp1 ;
83806   Dali::Toolkit::GaussianBlurView result;
83807
83808   argp1 = (Dali::BaseHandle *)jarg1;
83809   if (!argp1) {
83810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83811     return 0;
83812   }
83813   arg1 = *argp1;
83814   {
83815     try {
83816       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
83817     } catch (std::out_of_range& e) {
83818       {
83819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83820       };
83821     } catch (std::exception& e) {
83822       {
83823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83824       };
83825     } catch (...) {
83826       {
83827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83828       };
83829     }
83830   }
83831   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83832   return jresult;
83833 }
83834
83835
83836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
83837   void * jresult ;
83838   Dali::Toolkit::GaussianBlurView result;
83839
83840   {
83841     try {
83842       result = Dali::Toolkit::GaussianBlurView::New();
83843     } catch (std::out_of_range& e) {
83844       {
83845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83846       };
83847     } catch (std::exception& e) {
83848       {
83849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83850       };
83851     } catch (...) {
83852       {
83853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83854       };
83855     }
83856   }
83857   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83858   return jresult;
83859 }
83860
83861
83862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
83863   void * jresult ;
83864   unsigned int arg1 ;
83865   float arg2 ;
83866   Dali::Pixel::Format arg3 ;
83867   float arg4 ;
83868   float arg5 ;
83869   bool arg6 ;
83870   Dali::Toolkit::GaussianBlurView result;
83871
83872   arg1 = (unsigned int)jarg1;
83873   arg2 = (float)jarg2;
83874   arg3 = (Dali::Pixel::Format)jarg3;
83875   arg4 = (float)jarg4;
83876   arg5 = (float)jarg5;
83877   arg6 = jarg6 ? true : false;
83878   {
83879     try {
83880       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
83881     } catch (std::out_of_range& e) {
83882       {
83883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83884       };
83885     } catch (std::exception& e) {
83886       {
83887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83888       };
83889     } catch (...) {
83890       {
83891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83892       };
83893     }
83894   }
83895   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83896   return jresult;
83897 }
83898
83899
83900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
83901   void * jresult ;
83902   unsigned int arg1 ;
83903   float arg2 ;
83904   Dali::Pixel::Format arg3 ;
83905   float arg4 ;
83906   float arg5 ;
83907   Dali::Toolkit::GaussianBlurView result;
83908
83909   arg1 = (unsigned int)jarg1;
83910   arg2 = (float)jarg2;
83911   arg3 = (Dali::Pixel::Format)jarg3;
83912   arg4 = (float)jarg4;
83913   arg5 = (float)jarg5;
83914   {
83915     try {
83916       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
83917     } catch (std::out_of_range& e) {
83918       {
83919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83920       };
83921     } catch (std::exception& e) {
83922       {
83923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83924       };
83925     } catch (...) {
83926       {
83927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83928       };
83929     }
83930   }
83931   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83932   return jresult;
83933 }
83934
83935
83936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
83937   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83938   Dali::Actor arg2 ;
83939   Dali::Actor *argp2 ;
83940
83941   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83942   argp2 = (Dali::Actor *)jarg2;
83943   if (!argp2) {
83944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83945     return ;
83946   }
83947   arg2 = *argp2;
83948   {
83949     try {
83950       (arg1)->Add(arg2);
83951     } catch (std::out_of_range& e) {
83952       {
83953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83954       };
83955     } catch (std::exception& e) {
83956       {
83957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83958       };
83959     } catch (...) {
83960       {
83961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83962       };
83963     }
83964   }
83965 }
83966
83967
83968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
83969   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83970   Dali::Actor arg2 ;
83971   Dali::Actor *argp2 ;
83972
83973   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83974   argp2 = (Dali::Actor *)jarg2;
83975   if (!argp2) {
83976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83977     return ;
83978   }
83979   arg2 = *argp2;
83980   {
83981     try {
83982       (arg1)->Remove(arg2);
83983     } catch (std::out_of_range& e) {
83984       {
83985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83986       };
83987     } catch (std::exception& e) {
83988       {
83989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83990       };
83991     } catch (...) {
83992       {
83993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83994       };
83995     }
83996   }
83997 }
83998
83999
84000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
84001   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84002
84003   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84004   {
84005     try {
84006       (arg1)->Activate();
84007     } catch (std::out_of_range& e) {
84008       {
84009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84010       };
84011     } catch (std::exception& e) {
84012       {
84013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84014       };
84015     } catch (...) {
84016       {
84017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84018       };
84019     }
84020   }
84021 }
84022
84023
84024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
84025   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84026
84027   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84028   {
84029     try {
84030       (arg1)->ActivateOnce();
84031     } catch (std::out_of_range& e) {
84032       {
84033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84034       };
84035     } catch (std::exception& e) {
84036       {
84037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84038       };
84039     } catch (...) {
84040       {
84041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84042       };
84043     }
84044   }
84045 }
84046
84047
84048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
84049   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84050
84051   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84052   {
84053     try {
84054       (arg1)->Deactivate();
84055     } catch (std::out_of_range& e) {
84056       {
84057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84058       };
84059     } catch (std::exception& e) {
84060       {
84061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84062       };
84063     } catch (...) {
84064       {
84065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84066       };
84067     }
84068   }
84069 }
84070
84071
84072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
84073   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84074   Dali::Image arg2 ;
84075   Dali::FrameBufferImage arg3 ;
84076   Dali::Image *argp2 ;
84077   Dali::FrameBufferImage *argp3 ;
84078
84079   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84080   argp2 = (Dali::Image *)jarg2;
84081   if (!argp2) {
84082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
84083     return ;
84084   }
84085   arg2 = *argp2;
84086   argp3 = (Dali::FrameBufferImage *)jarg3;
84087   if (!argp3) {
84088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
84089     return ;
84090   }
84091   arg3 = *argp3;
84092   {
84093     try {
84094       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
84095     } catch (std::out_of_range& e) {
84096       {
84097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84098       };
84099     } catch (std::exception& e) {
84100       {
84101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84102       };
84103     } catch (...) {
84104       {
84105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84106       };
84107     }
84108   }
84109 }
84110
84111
84112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
84113   int jresult ;
84114   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84115   Dali::Property::Index result;
84116
84117   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84118   {
84119     try {
84120       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
84121     } catch (std::out_of_range& e) {
84122       {
84123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84124       };
84125     } catch (std::exception& e) {
84126       {
84127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84128       };
84129     } catch (...) {
84130       {
84131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84132       };
84133     }
84134   }
84135   jresult = result;
84136   return jresult;
84137 }
84138
84139
84140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
84141   void * jresult ;
84142   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84143   Dali::FrameBufferImage result;
84144
84145   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84146   {
84147     try {
84148       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
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::FrameBufferImage((const Dali::FrameBufferImage &)result);
84164   return jresult;
84165 }
84166
84167
84168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
84169   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84170   Dali::Vector4 *arg2 = 0 ;
84171
84172   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84173   arg2 = (Dali::Vector4 *)jarg2;
84174   if (!arg2) {
84175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
84176     return ;
84177   }
84178   {
84179     try {
84180       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
84181     } catch (std::out_of_range& e) {
84182       {
84183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84184       };
84185     } catch (std::exception& e) {
84186       {
84187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84188       };
84189     } catch (...) {
84190       {
84191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84192       };
84193     }
84194   }
84195 }
84196
84197
84198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
84199   void * jresult ;
84200   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84201   Dali::Vector4 result;
84202
84203   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84204   {
84205     try {
84206       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
84207     } catch (std::out_of_range& e) {
84208       {
84209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84210       };
84211     } catch (std::exception& e) {
84212       {
84213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84214       };
84215     } catch (...) {
84216       {
84217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84218       };
84219     }
84220   }
84221   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
84222   return jresult;
84223 }
84224
84225
84226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
84227   void * jresult ;
84228   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84229   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
84230
84231   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84232   {
84233     try {
84234       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
84235     } catch (std::out_of_range& e) {
84236       {
84237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84238       };
84239     } catch (std::exception& e) {
84240       {
84241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84242       };
84243     } catch (...) {
84244       {
84245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84246       };
84247     }
84248   }
84249   jresult = (void *)result;
84250   return jresult;
84251 }
84252
84253
84254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
84255   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84256
84257   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84258   {
84259     try {
84260       delete arg1;
84261     } catch (std::out_of_range& e) {
84262       {
84263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84264       };
84265     } catch (std::exception& e) {
84266       {
84267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84268       };
84269     } catch (...) {
84270       {
84271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84272       };
84273     }
84274   }
84275 }
84276
84277
84278 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
84279   unsigned int jresult ;
84280   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84281   unsigned int result;
84282
84283   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84284   {
84285     try {
84286       result = (unsigned int)(arg1)->GetNumberOfPages();
84287     } catch (std::out_of_range& e) {
84288       {
84289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84290       };
84291     } catch (std::exception& e) {
84292       {
84293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84294       };
84295     } catch (...) {
84296       {
84297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84298       };
84299     }
84300   }
84301   jresult = result;
84302   return jresult;
84303 }
84304
84305
84306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
84307   void * jresult ;
84308   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84309   unsigned int arg2 ;
84310   Dali::Texture result;
84311
84312   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84313   arg2 = (unsigned int)jarg2;
84314   {
84315     try {
84316       result = (arg1)->NewPage(arg2);
84317     } catch (std::out_of_range& e) {
84318       {
84319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84320       };
84321     } catch (std::exception& e) {
84322       {
84323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84324       };
84325     } catch (...) {
84326       {
84327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84328       };
84329     }
84330   }
84331   jresult = new Dali::Texture((const Dali::Texture &)result);
84332   return jresult;
84333 }
84334
84335
84336 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
84337   int jresult ;
84338   int result;
84339
84340   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
84341   jresult = (int)result;
84342   return jresult;
84343 }
84344
84345
84346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
84347   int jresult ;
84348   int result;
84349
84350   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
84351   jresult = (int)result;
84352   return jresult;
84353 }
84354
84355
84356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
84357   int jresult ;
84358   int result;
84359
84360   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
84361   jresult = (int)result;
84362   return jresult;
84363 }
84364
84365
84366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
84367   void * jresult ;
84368   Dali::Toolkit::PageTurnView::Property *result = 0 ;
84369
84370   {
84371     try {
84372       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
84373     } catch (std::out_of_range& e) {
84374       {
84375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84376       };
84377     } catch (std::exception& e) {
84378       {
84379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84380       };
84381     } catch (...) {
84382       {
84383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84384       };
84385     }
84386   }
84387   jresult = (void *)result;
84388   return jresult;
84389 }
84390
84391
84392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
84393   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
84394
84395   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
84396   {
84397     try {
84398       delete arg1;
84399     } catch (std::out_of_range& e) {
84400       {
84401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84402       };
84403     } catch (std::exception& e) {
84404       {
84405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84406       };
84407     } catch (...) {
84408       {
84409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84410       };
84411     }
84412   }
84413 }
84414
84415
84416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
84417   void * jresult ;
84418   Dali::Toolkit::PageTurnView *result = 0 ;
84419
84420   {
84421     try {
84422       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
84423     } catch (std::out_of_range& e) {
84424       {
84425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84426       };
84427     } catch (std::exception& e) {
84428       {
84429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84430       };
84431     } catch (...) {
84432       {
84433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84434       };
84435     }
84436   }
84437   jresult = (void *)result;
84438   return jresult;
84439 }
84440
84441
84442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
84443   void * jresult ;
84444   Dali::Toolkit::PageTurnView *arg1 = 0 ;
84445   Dali::Toolkit::PageTurnView *result = 0 ;
84446
84447   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84448   if (!arg1) {
84449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84450     return 0;
84451   }
84452   {
84453     try {
84454       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
84455     } catch (std::out_of_range& e) {
84456       {
84457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84458       };
84459     } catch (std::exception& e) {
84460       {
84461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84462       };
84463     } catch (...) {
84464       {
84465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84466       };
84467     }
84468   }
84469   jresult = (void *)result;
84470   return jresult;
84471 }
84472
84473
84474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
84475   void * jresult ;
84476   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84477   Dali::Toolkit::PageTurnView *arg2 = 0 ;
84478   Dali::Toolkit::PageTurnView *result = 0 ;
84479
84480   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84481   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
84482   if (!arg2) {
84483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84484     return 0;
84485   }
84486   {
84487     try {
84488       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
84489     } catch (std::out_of_range& e) {
84490       {
84491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84492       };
84493     } catch (std::exception& e) {
84494       {
84495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84496       };
84497     } catch (...) {
84498       {
84499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84500       };
84501     }
84502   }
84503   jresult = (void *)result;
84504   return jresult;
84505 }
84506
84507
84508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
84509   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84510
84511   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84512   {
84513     try {
84514       delete arg1;
84515     } catch (std::out_of_range& e) {
84516       {
84517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84518       };
84519     } catch (std::exception& e) {
84520       {
84521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84522       };
84523     } catch (...) {
84524       {
84525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84526       };
84527     }
84528   }
84529 }
84530
84531
84532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
84533   void * jresult ;
84534   Dali::BaseHandle arg1 ;
84535   Dali::BaseHandle *argp1 ;
84536   Dali::Toolkit::PageTurnView result;
84537
84538   argp1 = (Dali::BaseHandle *)jarg1;
84539   if (!argp1) {
84540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84541     return 0;
84542   }
84543   arg1 = *argp1;
84544   {
84545     try {
84546       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
84547     } catch (std::out_of_range& e) {
84548       {
84549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84550       };
84551     } catch (std::exception& e) {
84552       {
84553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84554       };
84555     } catch (...) {
84556       {
84557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84558       };
84559     }
84560   }
84561   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
84562   return jresult;
84563 }
84564
84565
84566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
84567   void * jresult ;
84568   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84569   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84570
84571   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84572   {
84573     try {
84574       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
84575     } catch (std::out_of_range& e) {
84576       {
84577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84578       };
84579     } catch (std::exception& e) {
84580       {
84581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84582       };
84583     } catch (...) {
84584       {
84585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84586       };
84587     }
84588   }
84589   jresult = (void *)result;
84590   return jresult;
84591 }
84592
84593
84594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
84595   void * jresult ;
84596   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84597   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84598
84599   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84600   {
84601     try {
84602       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
84603     } catch (std::out_of_range& e) {
84604       {
84605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84606       };
84607     } catch (std::exception& e) {
84608       {
84609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84610       };
84611     } catch (...) {
84612       {
84613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84614       };
84615     }
84616   }
84617   jresult = (void *)result;
84618   return jresult;
84619 }
84620
84621
84622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
84623   void * jresult ;
84624   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84625   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
84626
84627   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84628   {
84629     try {
84630       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
84631     } catch (std::out_of_range& e) {
84632       {
84633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84634       };
84635     } catch (std::exception& e) {
84636       {
84637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84638       };
84639     } catch (...) {
84640       {
84641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84642       };
84643     }
84644   }
84645   jresult = (void *)result;
84646   return jresult;
84647 }
84648
84649
84650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
84651   void * jresult ;
84652   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84653   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
84654
84655   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84656   {
84657     try {
84658       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
84659     } catch (std::out_of_range& e) {
84660       {
84661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84662       };
84663     } catch (std::exception& e) {
84664       {
84665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84666       };
84667     } catch (...) {
84668       {
84669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84670       };
84671     }
84672   }
84673   jresult = (void *)result;
84674   return jresult;
84675 }
84676
84677
84678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
84679   void * jresult ;
84680   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84681
84682   {
84683     try {
84684       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
84685     } catch (std::out_of_range& e) {
84686       {
84687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84688       };
84689     } catch (std::exception& e) {
84690       {
84691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84692       };
84693     } catch (...) {
84694       {
84695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84696       };
84697     }
84698   }
84699   jresult = (void *)result;
84700   return jresult;
84701 }
84702
84703
84704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
84705   void * jresult ;
84706   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
84707   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84708
84709   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84710   if (!arg1) {
84711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
84712     return 0;
84713   }
84714   {
84715     try {
84716       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
84717     } catch (std::out_of_range& e) {
84718       {
84719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84720       };
84721     } catch (std::exception& e) {
84722       {
84723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84724       };
84725     } catch (...) {
84726       {
84727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84728       };
84729     }
84730   }
84731   jresult = (void *)result;
84732   return jresult;
84733 }
84734
84735
84736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
84737   void * jresult ;
84738   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
84739   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
84740   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84741
84742   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84743   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
84744   if (!arg2) {
84745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
84746     return 0;
84747   }
84748   {
84749     try {
84750       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
84751     } catch (std::out_of_range& e) {
84752       {
84753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84754       };
84755     } catch (std::exception& e) {
84756       {
84757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84758       };
84759     } catch (...) {
84760       {
84761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84762       };
84763     }
84764   }
84765   jresult = (void *)result;
84766   return jresult;
84767 }
84768
84769
84770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
84771   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
84772
84773   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84774   {
84775     try {
84776       delete arg1;
84777     } catch (std::out_of_range& e) {
84778       {
84779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84780       };
84781     } catch (std::exception& e) {
84782       {
84783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84784       };
84785     } catch (...) {
84786       {
84787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84788       };
84789     }
84790   }
84791 }
84792
84793
84794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
84795   void * jresult ;
84796   Dali::Toolkit::PageFactory *arg1 = 0 ;
84797   Dali::Vector2 *arg2 = 0 ;
84798   Dali::Toolkit::PageTurnLandscapeView result;
84799
84800   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84801   if (!arg1) {
84802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
84803     return 0;
84804   }
84805   arg2 = (Dali::Vector2 *)jarg2;
84806   if (!arg2) {
84807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
84808     return 0;
84809   }
84810   {
84811     try {
84812       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
84813     } catch (std::out_of_range& e) {
84814       {
84815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84816       };
84817     } catch (std::exception& e) {
84818       {
84819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84820       };
84821     } catch (...) {
84822       {
84823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84824       };
84825     }
84826   }
84827   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
84828   return jresult;
84829 }
84830
84831
84832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
84833   void * jresult ;
84834   Dali::BaseHandle arg1 ;
84835   Dali::BaseHandle *argp1 ;
84836   Dali::Toolkit::PageTurnLandscapeView result;
84837
84838   argp1 = (Dali::BaseHandle *)jarg1;
84839   if (!argp1) {
84840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84841     return 0;
84842   }
84843   arg1 = *argp1;
84844   {
84845     try {
84846       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
84847     } catch (std::out_of_range& e) {
84848       {
84849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84850       };
84851     } catch (std::exception& e) {
84852       {
84853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84854       };
84855     } catch (...) {
84856       {
84857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84858       };
84859     }
84860   }
84861   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
84862   return jresult;
84863 }
84864
84865
84866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
84867   void * jresult ;
84868   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
84869
84870   {
84871     try {
84872       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
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 = (void *)result;
84888   return jresult;
84889 }
84890
84891
84892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
84893   void * jresult ;
84894   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
84895   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
84896
84897   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
84898   if (!arg1) {
84899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
84900     return 0;
84901   }
84902   {
84903     try {
84904       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
84905     } catch (std::out_of_range& e) {
84906       {
84907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84908       };
84909     } catch (std::exception& e) {
84910       {
84911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84912       };
84913     } catch (...) {
84914       {
84915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84916       };
84917     }
84918   }
84919   jresult = (void *)result;
84920   return jresult;
84921 }
84922
84923
84924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
84925   void * jresult ;
84926   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
84927   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
84928   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
84929
84930   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
84931   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
84932   if (!arg2) {
84933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
84934     return 0;
84935   }
84936   {
84937     try {
84938       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
84939     } catch (std::out_of_range& e) {
84940       {
84941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84942       };
84943     } catch (std::exception& e) {
84944       {
84945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84946       };
84947     } catch (...) {
84948       {
84949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84950       };
84951     }
84952   }
84953   jresult = (void *)result;
84954   return jresult;
84955 }
84956
84957
84958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
84959   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
84960
84961   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
84962   {
84963     try {
84964       delete arg1;
84965     } catch (std::out_of_range& e) {
84966       {
84967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84968       };
84969     } catch (std::exception& e) {
84970       {
84971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84972       };
84973     } catch (...) {
84974       {
84975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84976       };
84977     }
84978   }
84979 }
84980
84981
84982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
84983   void * jresult ;
84984   Dali::Toolkit::PageFactory *arg1 = 0 ;
84985   Dali::Vector2 *arg2 = 0 ;
84986   Dali::Toolkit::PageTurnPortraitView result;
84987
84988   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84989   if (!arg1) {
84990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
84991     return 0;
84992   }
84993   arg2 = (Dali::Vector2 *)jarg2;
84994   if (!arg2) {
84995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
84996     return 0;
84997   }
84998   {
84999     try {
85000       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
85001     } catch (std::out_of_range& e) {
85002       {
85003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85004       };
85005     } catch (std::exception& e) {
85006       {
85007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85008       };
85009     } catch (...) {
85010       {
85011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85012       };
85013     }
85014   }
85015   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85016   return jresult;
85017 }
85018
85019
85020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
85021   void * jresult ;
85022   Dali::BaseHandle arg1 ;
85023   Dali::BaseHandle *argp1 ;
85024   Dali::Toolkit::PageTurnPortraitView result;
85025
85026   argp1 = (Dali::BaseHandle *)jarg1;
85027   if (!argp1) {
85028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85029     return 0;
85030   }
85031   arg1 = *argp1;
85032   {
85033     try {
85034       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
85035     } catch (std::out_of_range& e) {
85036       {
85037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85038       };
85039     } catch (std::exception& e) {
85040       {
85041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85042       };
85043     } catch (...) {
85044       {
85045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85046       };
85047     }
85048   }
85049   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85050   return jresult;
85051 }
85052
85053
85054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
85055   int jresult ;
85056   int result;
85057
85058   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
85059   jresult = (int)result;
85060   return jresult;
85061 }
85062
85063
85064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
85065   int jresult ;
85066   int result;
85067
85068   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
85069   jresult = (int)result;
85070   return jresult;
85071 }
85072
85073
85074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
85075   int jresult ;
85076   int result;
85077
85078   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
85079   jresult = (int)result;
85080   return jresult;
85081 }
85082
85083
85084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
85085   void * jresult ;
85086   Dali::Toolkit::ToggleButton::Property *result = 0 ;
85087
85088   {
85089     try {
85090       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
85091     } catch (std::out_of_range& e) {
85092       {
85093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85094       };
85095     } catch (std::exception& e) {
85096       {
85097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85098       };
85099     } catch (...) {
85100       {
85101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85102       };
85103     }
85104   }
85105   jresult = (void *)result;
85106   return jresult;
85107 }
85108
85109
85110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
85111   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
85112
85113   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
85114   {
85115     try {
85116       delete arg1;
85117     } catch (std::out_of_range& e) {
85118       {
85119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85120       };
85121     } catch (std::exception& e) {
85122       {
85123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85124       };
85125     } catch (...) {
85126       {
85127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85128       };
85129     }
85130   }
85131 }
85132
85133
85134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
85135   void * jresult ;
85136   Dali::Toolkit::ToggleButton *result = 0 ;
85137
85138   {
85139     try {
85140       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
85141     } catch (std::out_of_range& e) {
85142       {
85143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85144       };
85145     } catch (std::exception& e) {
85146       {
85147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85148       };
85149     } catch (...) {
85150       {
85151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85152       };
85153     }
85154   }
85155   jresult = (void *)result;
85156   return jresult;
85157 }
85158
85159
85160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
85161   void * jresult ;
85162   Dali::Toolkit::ToggleButton *arg1 = 0 ;
85163   Dali::Toolkit::ToggleButton *result = 0 ;
85164
85165   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85166   if (!arg1) {
85167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85168     return 0;
85169   }
85170   {
85171     try {
85172       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
85173     } catch (std::out_of_range& e) {
85174       {
85175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85176       };
85177     } catch (std::exception& e) {
85178       {
85179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85180       };
85181     } catch (...) {
85182       {
85183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85184       };
85185     }
85186   }
85187   jresult = (void *)result;
85188   return jresult;
85189 }
85190
85191
85192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
85193   void * jresult ;
85194   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85195   Dali::Toolkit::ToggleButton *arg2 = 0 ;
85196   Dali::Toolkit::ToggleButton *result = 0 ;
85197
85198   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85199   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
85200   if (!arg2) {
85201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85202     return 0;
85203   }
85204   {
85205     try {
85206       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
85207     } catch (std::out_of_range& e) {
85208       {
85209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85210       };
85211     } catch (std::exception& e) {
85212       {
85213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85214       };
85215     } catch (...) {
85216       {
85217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85218       };
85219     }
85220   }
85221   jresult = (void *)result;
85222   return jresult;
85223 }
85224
85225
85226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
85227   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85228
85229   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85230   {
85231     try {
85232       delete arg1;
85233     } catch (std::out_of_range& e) {
85234       {
85235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85236       };
85237     } catch (std::exception& e) {
85238       {
85239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85240       };
85241     } catch (...) {
85242       {
85243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85244       };
85245     }
85246   }
85247 }
85248
85249
85250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
85251   void * jresult ;
85252   Dali::Toolkit::ToggleButton result;
85253
85254   {
85255     try {
85256       result = Dali::Toolkit::ToggleButton::New();
85257     } catch (std::out_of_range& e) {
85258       {
85259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85260       };
85261     } catch (std::exception& e) {
85262       {
85263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85264       };
85265     } catch (...) {
85266       {
85267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85268       };
85269     }
85270   }
85271   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
85272   return jresult;
85273 }
85274
85275
85276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
85277   void * jresult ;
85278   Dali::BaseHandle arg1 ;
85279   Dali::BaseHandle *argp1 ;
85280   Dali::Toolkit::ToggleButton result;
85281
85282   argp1 = (Dali::BaseHandle *)jarg1;
85283   if (!argp1) {
85284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85285     return 0;
85286   }
85287   arg1 = *argp1;
85288   {
85289     try {
85290       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
85291     } catch (std::out_of_range& e) {
85292       {
85293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85294       };
85295     } catch (std::exception& e) {
85296       {
85297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85298       };
85299     } catch (...) {
85300       {
85301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85302       };
85303     }
85304   }
85305   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
85306   return jresult;
85307 }
85308
85309
85310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
85311   void * jresult ;
85312   Dali::Toolkit::Visual::Base *result = 0 ;
85313
85314   {
85315     try {
85316       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
85317     } catch (std::out_of_range& e) {
85318       {
85319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85320       };
85321     } catch (std::exception& e) {
85322       {
85323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85324       };
85325     } catch (...) {
85326       {
85327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85328       };
85329     }
85330   }
85331   jresult = (void *)result;
85332   return jresult;
85333 }
85334
85335
85336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
85337   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85338
85339   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85340   {
85341     try {
85342       delete arg1;
85343     } catch (std::out_of_range& e) {
85344       {
85345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85346       };
85347     } catch (std::exception& e) {
85348       {
85349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85350       };
85351     } catch (...) {
85352       {
85353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85354       };
85355     }
85356   }
85357 }
85358
85359
85360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
85361   void * jresult ;
85362   Dali::Toolkit::Visual::Base *arg1 = 0 ;
85363   Dali::Toolkit::Visual::Base *result = 0 ;
85364
85365   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85366   if (!arg1) {
85367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
85368     return 0;
85369   }
85370   {
85371     try {
85372       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
85373     } catch (std::out_of_range& e) {
85374       {
85375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85376       };
85377     } catch (std::exception& e) {
85378       {
85379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85380       };
85381     } catch (...) {
85382       {
85383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85384       };
85385     }
85386   }
85387   jresult = (void *)result;
85388   return jresult;
85389 }
85390
85391
85392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
85393   void * jresult ;
85394   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85395   Dali::Toolkit::Visual::Base *arg2 = 0 ;
85396   Dali::Toolkit::Visual::Base *result = 0 ;
85397
85398   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85399   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
85400   if (!arg2) {
85401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
85402     return 0;
85403   }
85404   {
85405     try {
85406       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
85407     } catch (std::out_of_range& e) {
85408       {
85409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85410       };
85411     } catch (std::exception& e) {
85412       {
85413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85414       };
85415     } catch (...) {
85416       {
85417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85418       };
85419     }
85420   }
85421   jresult = (void *)result;
85422   return jresult;
85423 }
85424
85425
85426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
85427   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85428   std::string *arg2 = 0 ;
85429
85430   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85431   if (!jarg2) {
85432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85433     return ;
85434   }
85435   std::string arg2_str(jarg2);
85436   arg2 = &arg2_str;
85437   {
85438     try {
85439       (arg1)->SetName((std::string const &)*arg2);
85440     } catch (std::out_of_range& e) {
85441       {
85442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85443       };
85444     } catch (std::exception& e) {
85445       {
85446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85447       };
85448     } catch (...) {
85449       {
85450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85451       };
85452     }
85453   }
85454
85455   //argout typemap for const std::string&
85456
85457 }
85458
85459
85460 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
85461   char * jresult ;
85462   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85463   std::string *result = 0 ;
85464
85465   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85466   {
85467     try {
85468       result = (std::string *) &(arg1)->GetName();
85469     } catch (std::out_of_range& e) {
85470       {
85471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85472       };
85473     } catch (std::exception& e) {
85474       {
85475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85476       };
85477     } catch (...) {
85478       {
85479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85480       };
85481     }
85482   }
85483   jresult = SWIG_csharp_string_callback(result->c_str());
85484   return jresult;
85485 }
85486
85487
85488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
85489   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85490   Dali::Property::Map *arg2 = 0 ;
85491   Dali::Size arg3 ;
85492   Dali::Size *argp3 ;
85493
85494   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85495   arg2 = (Dali::Property::Map *)jarg2;
85496   if (!arg2) {
85497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
85498     return ;
85499   }
85500   argp3 = (Dali::Size *)jarg3;
85501   if (!argp3) {
85502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
85503     return ;
85504   }
85505   arg3 = *argp3;
85506   {
85507     try {
85508       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
85509     } catch (std::out_of_range& e) {
85510       {
85511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85512       };
85513     } catch (std::exception& e) {
85514       {
85515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85516       };
85517     } catch (...) {
85518       {
85519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85520       };
85521     }
85522   }
85523 }
85524
85525
85526 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
85527   float jresult ;
85528   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85529   float arg2 ;
85530   float result;
85531
85532   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85533   arg2 = (float)jarg2;
85534   {
85535     try {
85536       result = (float)(arg1)->GetHeightForWidth(arg2);
85537     } catch (std::out_of_range& e) {
85538       {
85539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85540       };
85541     } catch (std::exception& e) {
85542       {
85543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85544       };
85545     } catch (...) {
85546       {
85547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85548       };
85549     }
85550   }
85551   jresult = result;
85552   return jresult;
85553 }
85554
85555
85556 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
85557   float jresult ;
85558   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85559   float arg2 ;
85560   float result;
85561
85562   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85563   arg2 = (float)jarg2;
85564   {
85565     try {
85566       result = (float)(arg1)->GetWidthForHeight(arg2);
85567     } catch (std::out_of_range& e) {
85568       {
85569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85570       };
85571     } catch (std::exception& e) {
85572       {
85573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85574       };
85575     } catch (...) {
85576       {
85577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85578       };
85579     }
85580   }
85581   jresult = result;
85582   return jresult;
85583 }
85584
85585
85586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
85587   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85588   Dali::Vector2 *arg2 = 0 ;
85589
85590   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85591   arg2 = (Dali::Vector2 *)jarg2;
85592   if (!arg2) {
85593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
85594     return ;
85595   }
85596   {
85597     try {
85598       (arg1)->GetNaturalSize(*arg2);
85599     } catch (std::out_of_range& e) {
85600       {
85601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85602       };
85603     } catch (std::exception& e) {
85604       {
85605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85606       };
85607     } catch (...) {
85608       {
85609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85610       };
85611     }
85612   }
85613 }
85614
85615
85616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, float jarg2) {
85617   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85618   float arg2 ;
85619
85620   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85621   arg2 = (float)jarg2;
85622   {
85623     try {
85624       (arg1)->SetDepthIndex(arg2);
85625     } catch (std::out_of_range& e) {
85626       {
85627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85628       };
85629     } catch (std::exception& e) {
85630       {
85631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85632       };
85633     } catch (...) {
85634       {
85635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85636       };
85637     }
85638   }
85639 }
85640
85641
85642 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
85643   float jresult ;
85644   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85645   float result;
85646
85647   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85648   {
85649     try {
85650       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
85651     } catch (std::out_of_range& e) {
85652       {
85653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85654       };
85655     } catch (std::exception& e) {
85656       {
85657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85658       };
85659     } catch (...) {
85660       {
85661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85662       };
85663     }
85664   }
85665   jresult = result;
85666   return jresult;
85667 }
85668
85669
85670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
85671   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85672   Dali::Property::Map *arg2 = 0 ;
85673
85674   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85675   arg2 = (Dali::Property::Map *)jarg2;
85676   if (!arg2) {
85677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
85678     return ;
85679   }
85680   {
85681     try {
85682       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
85683     } catch (std::out_of_range& e) {
85684       {
85685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85686       };
85687     } catch (std::exception& e) {
85688       {
85689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85690       };
85691     } catch (...) {
85692       {
85693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85694       };
85695     }
85696   }
85697 }
85698
85699
85700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
85701   void * jresult ;
85702   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
85703   Dali::Toolkit::Visual::Base *result = 0 ;
85704
85705   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
85706   {
85707     try {
85708       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
85709     } catch (std::out_of_range& e) {
85710       {
85711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85712       };
85713     } catch (std::exception& e) {
85714       {
85715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85716       };
85717     } catch (...) {
85718       {
85719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85720       };
85721     }
85722   }
85723   jresult = (void *)result;
85724   return jresult;
85725 }
85726
85727
85728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
85729   void * jresult ;
85730   Dali::Toolkit::VisualFactory result;
85731
85732   {
85733     try {
85734       result = Dali::Toolkit::VisualFactory::Get();
85735     } catch (std::out_of_range& e) {
85736       {
85737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85738       };
85739     } catch (std::exception& e) {
85740       {
85741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85742       };
85743     } catch (...) {
85744       {
85745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85746       };
85747     }
85748   }
85749   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
85750   return jresult;
85751 }
85752
85753
85754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
85755   void * jresult ;
85756   Dali::Toolkit::VisualFactory *result = 0 ;
85757
85758   {
85759     try {
85760       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
85761     } catch (std::out_of_range& e) {
85762       {
85763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85764       };
85765     } catch (std::exception& e) {
85766       {
85767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85768       };
85769     } catch (...) {
85770       {
85771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85772       };
85773     }
85774   }
85775   jresult = (void *)result;
85776   return jresult;
85777 }
85778
85779
85780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
85781   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85782
85783   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85784   {
85785     try {
85786       delete arg1;
85787     } catch (std::out_of_range& e) {
85788       {
85789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85790       };
85791     } catch (std::exception& e) {
85792       {
85793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85794       };
85795     } catch (...) {
85796       {
85797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85798       };
85799     }
85800   }
85801 }
85802
85803
85804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
85805   void * jresult ;
85806   Dali::Toolkit::VisualFactory *arg1 = 0 ;
85807   Dali::Toolkit::VisualFactory *result = 0 ;
85808
85809   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85810   if (!arg1) {
85811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
85812     return 0;
85813   }
85814   {
85815     try {
85816       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
85817     } catch (std::out_of_range& e) {
85818       {
85819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85820       };
85821     } catch (std::exception& e) {
85822       {
85823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85824       };
85825     } catch (...) {
85826       {
85827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85828       };
85829     }
85830   }
85831   jresult = (void *)result;
85832   return jresult;
85833 }
85834
85835
85836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
85837   void * jresult ;
85838   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85839   Dali::Toolkit::VisualFactory *arg2 = 0 ;
85840   Dali::Toolkit::VisualFactory *result = 0 ;
85841
85842   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85843   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
85844   if (!arg2) {
85845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
85846     return 0;
85847   }
85848   {
85849     try {
85850       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
85851     } catch (std::out_of_range& e) {
85852       {
85853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85854       };
85855     } catch (std::exception& e) {
85856       {
85857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85858       };
85859     } catch (...) {
85860       {
85861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85862       };
85863     }
85864   }
85865   jresult = (void *)result;
85866   return jresult;
85867 }
85868
85869
85870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
85871   void * jresult ;
85872   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85873   Dali::Property::Map *arg2 = 0 ;
85874   Dali::Toolkit::Visual::Base result;
85875
85876   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85877   arg2 = (Dali::Property::Map *)jarg2;
85878   if (!arg2) {
85879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
85880     return 0;
85881   }
85882   {
85883     try {
85884       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
85885     } catch (std::out_of_range& e) {
85886       {
85887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85888       };
85889     } catch (std::exception& e) {
85890       {
85891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85892       };
85893     } catch (...) {
85894       {
85895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85896       };
85897     }
85898   }
85899   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
85900   return jresult;
85901 }
85902
85903
85904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
85905   void * jresult ;
85906   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85907   Dali::Image *arg2 = 0 ;
85908   Dali::Toolkit::Visual::Base result;
85909
85910   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85911   arg2 = (Dali::Image *)jarg2;
85912   if (!arg2) {
85913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
85914     return 0;
85915   }
85916   {
85917     try {
85918       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
85919     } catch (std::out_of_range& e) {
85920       {
85921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85922       };
85923     } catch (std::exception& e) {
85924       {
85925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85926       };
85927     } catch (...) {
85928       {
85929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85930       };
85931     }
85932   }
85933   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
85934   return jresult;
85935 }
85936
85937
85938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
85939   void * jresult ;
85940   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85941   std::string *arg2 = 0 ;
85942   Dali::ImageDimensions arg3 ;
85943   Dali::ImageDimensions *argp3 ;
85944   Dali::Toolkit::Visual::Base result;
85945
85946   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85947   if (!jarg2) {
85948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85949     return 0;
85950   }
85951   std::string arg2_str(jarg2);
85952   arg2 = &arg2_str;
85953   argp3 = (Dali::ImageDimensions *)jarg3;
85954   if (!argp3) {
85955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85956     return 0;
85957   }
85958   arg3 = *argp3;
85959   {
85960     try {
85961       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
85962     } catch (std::out_of_range& e) {
85963       {
85964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85965       };
85966     } catch (std::exception& e) {
85967       {
85968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85969       };
85970     } catch (...) {
85971       {
85972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85973       };
85974     }
85975   }
85976   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
85977
85978   //argout typemap for const std::string&
85979
85980   return jresult;
85981 }
85982
85983
85984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
85985   void * jresult ;
85986   Dali::Toolkit::AsyncImageLoader *result = 0 ;
85987
85988   {
85989     try {
85990       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
85991     } catch (std::out_of_range& e) {
85992       {
85993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85994       };
85995     } catch (std::exception& e) {
85996       {
85997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85998       };
85999     } catch (...) {
86000       {
86001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86002       };
86003     }
86004   }
86005   jresult = (void *)result;
86006   return jresult;
86007 }
86008
86009
86010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
86011   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86012
86013   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86014   {
86015     try {
86016       delete arg1;
86017     } catch (std::out_of_range& e) {
86018       {
86019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86020       };
86021     } catch (std::exception& e) {
86022       {
86023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86024       };
86025     } catch (...) {
86026       {
86027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86028       };
86029     }
86030   }
86031 }
86032
86033
86034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
86035   void * jresult ;
86036   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
86037   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86038
86039   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86040   if (!arg1) {
86041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86042     return 0;
86043   }
86044   {
86045     try {
86046       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
86047     } catch (std::out_of_range& e) {
86048       {
86049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86050       };
86051     } catch (std::exception& e) {
86052       {
86053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86054       };
86055     } catch (...) {
86056       {
86057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86058       };
86059     }
86060   }
86061   jresult = (void *)result;
86062   return jresult;
86063 }
86064
86065
86066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
86067   void * jresult ;
86068   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86069   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
86070   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86071
86072   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86073   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
86074   if (!arg2) {
86075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86076     return 0;
86077   }
86078   {
86079     try {
86080       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
86081     } catch (std::out_of_range& e) {
86082       {
86083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86084       };
86085     } catch (std::exception& e) {
86086       {
86087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86088       };
86089     } catch (...) {
86090       {
86091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86092       };
86093     }
86094   }
86095   jresult = (void *)result;
86096   return jresult;
86097 }
86098
86099
86100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
86101   void * jresult ;
86102   Dali::Toolkit::AsyncImageLoader result;
86103
86104   {
86105     try {
86106       result = Dali::Toolkit::AsyncImageLoader::New();
86107     } catch (std::out_of_range& e) {
86108       {
86109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86110       };
86111     } catch (std::exception& e) {
86112       {
86113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86114       };
86115     } catch (...) {
86116       {
86117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86118       };
86119     }
86120   }
86121   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86122   return jresult;
86123 }
86124
86125
86126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
86127   void * jresult ;
86128   Dali::BaseHandle arg1 ;
86129   Dali::BaseHandle *argp1 ;
86130   Dali::Toolkit::AsyncImageLoader result;
86131
86132   argp1 = (Dali::BaseHandle *)jarg1;
86133   if (!argp1) {
86134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86135     return 0;
86136   }
86137   arg1 = *argp1;
86138   {
86139     try {
86140       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
86141     } catch (std::out_of_range& e) {
86142       {
86143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86144       };
86145     } catch (std::exception& e) {
86146       {
86147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86148       };
86149     } catch (...) {
86150       {
86151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86152       };
86153     }
86154   }
86155   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86156   return jresult;
86157 }
86158
86159
86160 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
86161   unsigned int jresult ;
86162   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86163   std::string *arg2 = 0 ;
86164   uint32_t result;
86165
86166   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86167   if (!jarg2) {
86168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86169     return 0;
86170   }
86171   std::string arg2_str(jarg2);
86172   arg2 = &arg2_str;
86173   {
86174     try {
86175       result = (arg1)->Load((std::string const &)*arg2);
86176     } catch (std::out_of_range& e) {
86177       {
86178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86179       };
86180     } catch (std::exception& e) {
86181       {
86182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86183       };
86184     } catch (...) {
86185       {
86186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86187       };
86188     }
86189   }
86190   jresult = result;
86191
86192   //argout typemap for const std::string&
86193
86194   return jresult;
86195 }
86196
86197
86198 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
86199   unsigned int jresult ;
86200   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86201   std::string *arg2 = 0 ;
86202   Dali::ImageDimensions arg3 ;
86203   Dali::ImageDimensions *argp3 ;
86204   uint32_t result;
86205
86206   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86207   if (!jarg2) {
86208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86209     return 0;
86210   }
86211   std::string arg2_str(jarg2);
86212   arg2 = &arg2_str;
86213   argp3 = (Dali::ImageDimensions *)jarg3;
86214   if (!argp3) {
86215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86216     return 0;
86217   }
86218   arg3 = *argp3;
86219   {
86220     try {
86221       result = (arg1)->Load((std::string const &)*arg2,arg3);
86222     } catch (std::out_of_range& e) {
86223       {
86224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86225       };
86226     } catch (std::exception& e) {
86227       {
86228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86229       };
86230     } catch (...) {
86231       {
86232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86233       };
86234     }
86235   }
86236   jresult = result;
86237
86238   //argout typemap for const std::string&
86239
86240   return jresult;
86241 }
86242
86243
86244 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
86245   unsigned int jresult ;
86246   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86247   std::string *arg2 = 0 ;
86248   Dali::ImageDimensions arg3 ;
86249   Dali::FittingMode::Type arg4 ;
86250   Dali::SamplingMode::Type arg5 ;
86251   bool arg6 ;
86252   Dali::ImageDimensions *argp3 ;
86253   uint32_t result;
86254
86255   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86256   if (!jarg2) {
86257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86258     return 0;
86259   }
86260   std::string arg2_str(jarg2);
86261   arg2 = &arg2_str;
86262   argp3 = (Dali::ImageDimensions *)jarg3;
86263   if (!argp3) {
86264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86265     return 0;
86266   }
86267   arg3 = *argp3;
86268   arg4 = (Dali::FittingMode::Type)jarg4;
86269   arg5 = (Dali::SamplingMode::Type)jarg5;
86270   arg6 = jarg6 ? true : false;
86271   {
86272     try {
86273       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
86274     } catch (std::out_of_range& e) {
86275       {
86276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86277       };
86278     } catch (std::exception& e) {
86279       {
86280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86281       };
86282     } catch (...) {
86283       {
86284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86285       };
86286     }
86287   }
86288   jresult = result;
86289
86290   //argout typemap for const std::string&
86291
86292   return jresult;
86293 }
86294
86295
86296 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
86297   unsigned int jresult ;
86298   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86299   uint32_t arg2 ;
86300   bool result;
86301
86302   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86303   arg2 = (uint32_t)jarg2;
86304   {
86305     try {
86306       result = (bool)(arg1)->Cancel(arg2);
86307     } catch (std::out_of_range& e) {
86308       {
86309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86310       };
86311     } catch (std::exception& e) {
86312       {
86313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86314       };
86315     } catch (...) {
86316       {
86317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86318       };
86319     }
86320   }
86321   jresult = result;
86322   return jresult;
86323 }
86324
86325
86326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
86327   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86328
86329   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86330   {
86331     try {
86332       (arg1)->CancelAll();
86333     } catch (std::out_of_range& e) {
86334       {
86335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86336       };
86337     } catch (std::exception& e) {
86338       {
86339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86340       };
86341     } catch (...) {
86342       {
86343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86344       };
86345     }
86346   }
86347 }
86348
86349
86350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
86351   void * jresult ;
86352   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86353   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
86354
86355   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86356   {
86357     try {
86358       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
86359     } catch (std::out_of_range& e) {
86360       {
86361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86362       };
86363     } catch (std::exception& e) {
86364       {
86365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86366       };
86367     } catch (...) {
86368       {
86369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86370       };
86371     }
86372   }
86373   jresult = (void *)result;
86374   return jresult;
86375 }
86376
86377
86378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_2(void * jarg1) {
86379   void * jresult ;
86380   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
86381   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86382
86383   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
86384   {
86385     try {
86386       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
86387     } catch (std::out_of_range& e) {
86388       {
86389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86390       };
86391     } catch (std::exception& e) {
86392       {
86393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86394       };
86395     } catch (...) {
86396       {
86397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86398       };
86399     }
86400   }
86401   jresult = (void *)result;
86402   return jresult;
86403 }
86404
86405
86406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
86407   void * jresult ;
86408   std::string *arg1 = 0 ;
86409   Dali::PixelData result;
86410
86411   if (!jarg1) {
86412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86413     return 0;
86414   }
86415   std::string arg1_str(jarg1);
86416   arg1 = &arg1_str;
86417   {
86418     try {
86419       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
86420     } catch (std::out_of_range& e) {
86421       {
86422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86423       };
86424     } catch (std::exception& e) {
86425       {
86426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86427       };
86428     } catch (...) {
86429       {
86430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86431       };
86432     }
86433   }
86434   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86435
86436   //argout typemap for const std::string&
86437
86438   return jresult;
86439 }
86440
86441
86442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
86443   void * jresult ;
86444   std::string *arg1 = 0 ;
86445   Dali::ImageDimensions arg2 ;
86446   Dali::ImageDimensions *argp2 ;
86447   Dali::PixelData result;
86448
86449   if (!jarg1) {
86450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86451     return 0;
86452   }
86453   std::string arg1_str(jarg1);
86454   arg1 = &arg1_str;
86455   argp2 = (Dali::ImageDimensions *)jarg2;
86456   if (!argp2) {
86457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86458     return 0;
86459   }
86460   arg2 = *argp2;
86461   {
86462     try {
86463       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
86464     } catch (std::out_of_range& e) {
86465       {
86466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86467       };
86468     } catch (std::exception& e) {
86469       {
86470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86471       };
86472     } catch (...) {
86473       {
86474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86475       };
86476     }
86477   }
86478   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86479
86480   //argout typemap for const std::string&
86481
86482   return jresult;
86483 }
86484
86485
86486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
86487   void * jresult ;
86488   std::string *arg1 = 0 ;
86489   Dali::ImageDimensions arg2 ;
86490   Dali::FittingMode::Type arg3 ;
86491   Dali::SamplingMode::Type arg4 ;
86492   bool arg5 ;
86493   Dali::ImageDimensions *argp2 ;
86494   Dali::PixelData result;
86495
86496   if (!jarg1) {
86497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86498     return 0;
86499   }
86500   std::string arg1_str(jarg1);
86501   arg1 = &arg1_str;
86502   argp2 = (Dali::ImageDimensions *)jarg2;
86503   if (!argp2) {
86504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86505     return 0;
86506   }
86507   arg2 = *argp2;
86508   arg3 = (Dali::FittingMode::Type)jarg3;
86509   arg4 = (Dali::SamplingMode::Type)jarg4;
86510   arg5 = jarg5 ? true : false;
86511   {
86512     try {
86513       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
86514     } catch (std::out_of_range& e) {
86515       {
86516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86517       };
86518     } catch (std::exception& e) {
86519       {
86520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86521       };
86522     } catch (...) {
86523       {
86524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86525       };
86526     }
86527   }
86528   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86529
86530   //argout typemap for const std::string&
86531
86532   return jresult;
86533 }
86534
86535
86536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
86537   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
86538
86539   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
86540   {
86541     try {
86542       delete arg1;
86543     } catch (std::out_of_range& e) {
86544       {
86545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86546       };
86547     } catch (std::exception& e) {
86548       {
86549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86550       };
86551     } catch (...) {
86552       {
86553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86554       };
86555     }
86556   }
86557 }
86558
86559
86560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
86561   void * jresult ;
86562   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
86563   Dali::Actor arg2 ;
86564   Dali::Actor arg3 ;
86565   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
86566   Dali::Actor *argp2 ;
86567   Dali::Actor *argp3 ;
86568   Dali::Actor result;
86569
86570   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
86571   argp2 = (Dali::Actor *)jarg2;
86572   if (!argp2) {
86573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86574     return 0;
86575   }
86576   arg2 = *argp2;
86577   argp3 = (Dali::Actor *)jarg3;
86578   if (!argp3) {
86579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86580     return 0;
86581   }
86582   arg3 = *argp3;
86583   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
86584   {
86585     try {
86586       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
86587     } catch (std::out_of_range& e) {
86588       {
86589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86590       };
86591     } catch (std::exception& e) {
86592       {
86593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86594       };
86595     } catch (...) {
86596       {
86597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86598       };
86599     }
86600   }
86601   jresult = new Dali::Actor((const Dali::Actor &)result);
86602   return jresult;
86603 }
86604
86605
86606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
86607   void * jresult ;
86608   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
86609
86610   {
86611     try {
86612       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
86613     } catch (std::out_of_range& e) {
86614       {
86615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86616       };
86617     } catch (std::exception& e) {
86618       {
86619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86620       };
86621     } catch (...) {
86622       {
86623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86624       };
86625     }
86626   }
86627   jresult = (void *)result;
86628   return jresult;
86629 }
86630
86631
86632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
86633   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
86634   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
86635   if (director) {
86636     director->swig_connect_director(callback0);
86637   }
86638 }
86639
86640
86641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
86642   KeyboardFocusManager arg1 ;
86643   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
86644   KeyboardFocusManager *argp1 ;
86645
86646   argp1 = (KeyboardFocusManager *)jarg1;
86647   if (!argp1) {
86648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
86649     return ;
86650   }
86651   arg1 = *argp1;
86652   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
86653   if (!arg2) {
86654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
86655     return ;
86656   }
86657   {
86658     try {
86659       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
86660     } catch (std::out_of_range& e) {
86661       {
86662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86663       };
86664     } catch (std::exception& e) {
86665       {
86666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86667       };
86668     } catch (...) {
86669       {
86670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86671       };
86672     }
86673   }
86674 }
86675
86676
86677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
86678   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86679
86680   arg1 = (std::vector< unsigned int > *)jarg1;
86681   {
86682     try {
86683       (arg1)->clear();
86684     } catch (std::out_of_range& e) {
86685       {
86686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86687       };
86688     } catch (std::exception& e) {
86689       {
86690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86691       };
86692     } catch (...) {
86693       {
86694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86695       };
86696     }
86697   }
86698 }
86699
86700
86701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
86702   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86703   unsigned int *arg2 = 0 ;
86704   unsigned int temp2 ;
86705
86706   arg1 = (std::vector< unsigned int > *)jarg1;
86707   temp2 = (unsigned int)jarg2;
86708   arg2 = &temp2;
86709   {
86710     try {
86711       (arg1)->push_back((unsigned int const &)*arg2);
86712     } catch (std::out_of_range& e) {
86713       {
86714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86715       };
86716     } catch (std::exception& e) {
86717       {
86718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86719       };
86720     } catch (...) {
86721       {
86722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86723       };
86724     }
86725   }
86726 }
86727
86728
86729 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
86730   unsigned long jresult ;
86731   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86732   std::vector< unsigned int >::size_type result;
86733
86734   arg1 = (std::vector< unsigned int > *)jarg1;
86735   {
86736     try {
86737       result = ((std::vector< unsigned int > const *)arg1)->size();
86738     } catch (std::out_of_range& e) {
86739       {
86740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86741       };
86742     } catch (std::exception& e) {
86743       {
86744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86745       };
86746     } catch (...) {
86747       {
86748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86749       };
86750     }
86751   }
86752   jresult = (unsigned long)result;
86753   return jresult;
86754 }
86755
86756
86757 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
86758   unsigned long jresult ;
86759   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86760   std::vector< unsigned int >::size_type result;
86761
86762   arg1 = (std::vector< unsigned int > *)jarg1;
86763   {
86764     try {
86765       result = ((std::vector< unsigned int > const *)arg1)->capacity();
86766     } catch (std::out_of_range& e) {
86767       {
86768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86769       };
86770     } catch (std::exception& e) {
86771       {
86772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86773       };
86774     } catch (...) {
86775       {
86776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86777       };
86778     }
86779   }
86780   jresult = (unsigned long)result;
86781   return jresult;
86782 }
86783
86784
86785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
86786   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86787   std::vector< unsigned int >::size_type arg2 ;
86788
86789   arg1 = (std::vector< unsigned int > *)jarg1;
86790   arg2 = (std::vector< unsigned int >::size_type)jarg2;
86791   {
86792     try {
86793       (arg1)->reserve(arg2);
86794     } catch (std::out_of_range& e) {
86795       {
86796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86797       };
86798     } catch (std::exception& e) {
86799       {
86800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86801       };
86802     } catch (...) {
86803       {
86804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86805       };
86806     }
86807   }
86808 }
86809
86810
86811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
86812   void * jresult ;
86813   std::vector< unsigned int > *result = 0 ;
86814
86815   {
86816     try {
86817       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
86818     } catch (std::out_of_range& e) {
86819       {
86820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86821       };
86822     } catch (std::exception& e) {
86823       {
86824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86825       };
86826     } catch (...) {
86827       {
86828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86829       };
86830     }
86831   }
86832   jresult = (void *)result;
86833   return jresult;
86834 }
86835
86836
86837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
86838   void * jresult ;
86839   std::vector< unsigned int > *arg1 = 0 ;
86840   std::vector< unsigned int > *result = 0 ;
86841
86842   arg1 = (std::vector< unsigned int > *)jarg1;
86843   if (!arg1) {
86844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
86845     return 0;
86846   }
86847   {
86848     try {
86849       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
86850     } catch (std::out_of_range& e) {
86851       {
86852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86853       };
86854     } catch (std::exception& e) {
86855       {
86856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86857       };
86858     } catch (...) {
86859       {
86860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86861       };
86862     }
86863   }
86864   jresult = (void *)result;
86865   return jresult;
86866 }
86867
86868
86869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
86870   void * jresult ;
86871   int arg1 ;
86872   std::vector< unsigned int > *result = 0 ;
86873
86874   arg1 = (int)jarg1;
86875   {
86876     try {
86877       try {
86878         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
86879       }
86880       catch(std::out_of_range &_e) {
86881         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86882         return 0;
86883       }
86884
86885     } catch (std::out_of_range& e) {
86886       {
86887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86888       };
86889     } catch (std::exception& e) {
86890       {
86891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86892       };
86893     } catch (...) {
86894       {
86895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86896       };
86897     }
86898   }
86899   jresult = (void *)result;
86900   return jresult;
86901 }
86902
86903
86904 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
86905   unsigned int jresult ;
86906   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86907   int arg2 ;
86908   unsigned int result;
86909
86910   arg1 = (std::vector< unsigned int > *)jarg1;
86911   arg2 = (int)jarg2;
86912   {
86913     try {
86914       try {
86915         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
86916       }
86917       catch(std::out_of_range &_e) {
86918         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86919         return 0;
86920       }
86921
86922     } catch (std::out_of_range& e) {
86923       {
86924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86925       };
86926     } catch (std::exception& e) {
86927       {
86928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86929       };
86930     } catch (...) {
86931       {
86932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86933       };
86934     }
86935   }
86936   jresult = result;
86937   return jresult;
86938 }
86939
86940
86941 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
86942   unsigned int jresult ;
86943   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86944   int arg2 ;
86945   unsigned int *result = 0 ;
86946
86947   arg1 = (std::vector< unsigned int > *)jarg1;
86948   arg2 = (int)jarg2;
86949   {
86950     try {
86951       try {
86952         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
86953       }
86954       catch(std::out_of_range &_e) {
86955         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86956         return 0;
86957       }
86958
86959     } catch (std::out_of_range& e) {
86960       {
86961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86962       };
86963     } catch (std::exception& e) {
86964       {
86965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86966       };
86967     } catch (...) {
86968       {
86969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86970       };
86971     }
86972   }
86973   jresult = *result;
86974   return jresult;
86975 }
86976
86977
86978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
86979   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86980   int arg2 ;
86981   unsigned int *arg3 = 0 ;
86982   unsigned int temp3 ;
86983
86984   arg1 = (std::vector< unsigned int > *)jarg1;
86985   arg2 = (int)jarg2;
86986   temp3 = (unsigned int)jarg3;
86987   arg3 = &temp3;
86988   {
86989     try {
86990       try {
86991         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
86992       }
86993       catch(std::out_of_range &_e) {
86994         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86995         return ;
86996       }
86997
86998     } catch (std::out_of_range& e) {
86999       {
87000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87001       };
87002     } catch (std::exception& e) {
87003       {
87004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87005       };
87006     } catch (...) {
87007       {
87008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87009       };
87010     }
87011   }
87012 }
87013
87014
87015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
87016   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87017   std::vector< unsigned int > *arg2 = 0 ;
87018
87019   arg1 = (std::vector< unsigned int > *)jarg1;
87020   arg2 = (std::vector< unsigned int > *)jarg2;
87021   if (!arg2) {
87022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87023     return ;
87024   }
87025   {
87026     try {
87027       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
87028     } catch (std::out_of_range& e) {
87029       {
87030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87031       };
87032     } catch (std::exception& e) {
87033       {
87034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87035       };
87036     } catch (...) {
87037       {
87038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87039       };
87040     }
87041   }
87042 }
87043
87044
87045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
87046   void * jresult ;
87047   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87048   int arg2 ;
87049   int arg3 ;
87050   std::vector< unsigned int > *result = 0 ;
87051
87052   arg1 = (std::vector< unsigned int > *)jarg1;
87053   arg2 = (int)jarg2;
87054   arg3 = (int)jarg3;
87055   {
87056     try {
87057       try {
87058         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
87059       }
87060       catch(std::out_of_range &_e) {
87061         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87062         return 0;
87063       }
87064       catch(std::invalid_argument &_e) {
87065         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87066         return 0;
87067       }
87068
87069     } catch (std::out_of_range& e) {
87070       {
87071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87072       };
87073     } catch (std::exception& e) {
87074       {
87075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87076       };
87077     } catch (...) {
87078       {
87079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87080       };
87081     }
87082   }
87083   jresult = (void *)result;
87084   return jresult;
87085 }
87086
87087
87088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
87089   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87090   int arg2 ;
87091   unsigned int *arg3 = 0 ;
87092   unsigned int temp3 ;
87093
87094   arg1 = (std::vector< unsigned int > *)jarg1;
87095   arg2 = (int)jarg2;
87096   temp3 = (unsigned int)jarg3;
87097   arg3 = &temp3;
87098   {
87099     try {
87100       try {
87101         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
87102       }
87103       catch(std::out_of_range &_e) {
87104         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87105         return ;
87106       }
87107
87108     } catch (std::out_of_range& e) {
87109       {
87110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87111       };
87112     } catch (std::exception& e) {
87113       {
87114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87115       };
87116     } catch (...) {
87117       {
87118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87119       };
87120     }
87121   }
87122 }
87123
87124
87125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
87126   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87127   int arg2 ;
87128   std::vector< unsigned int > *arg3 = 0 ;
87129
87130   arg1 = (std::vector< unsigned int > *)jarg1;
87131   arg2 = (int)jarg2;
87132   arg3 = (std::vector< unsigned int > *)jarg3;
87133   if (!arg3) {
87134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87135     return ;
87136   }
87137   {
87138     try {
87139       try {
87140         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
87141       }
87142       catch(std::out_of_range &_e) {
87143         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87144         return ;
87145       }
87146
87147     } catch (std::out_of_range& e) {
87148       {
87149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87150       };
87151     } catch (std::exception& e) {
87152       {
87153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87154       };
87155     } catch (...) {
87156       {
87157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87158       };
87159     }
87160   }
87161 }
87162
87163
87164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
87165   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87166   int arg2 ;
87167
87168   arg1 = (std::vector< unsigned int > *)jarg1;
87169   arg2 = (int)jarg2;
87170   {
87171     try {
87172       try {
87173         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
87174       }
87175       catch(std::out_of_range &_e) {
87176         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87177         return ;
87178       }
87179
87180     } catch (std::out_of_range& e) {
87181       {
87182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87183       };
87184     } catch (std::exception& e) {
87185       {
87186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87187       };
87188     } catch (...) {
87189       {
87190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87191       };
87192     }
87193   }
87194 }
87195
87196
87197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
87198   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87199   int arg2 ;
87200   int arg3 ;
87201
87202   arg1 = (std::vector< unsigned int > *)jarg1;
87203   arg2 = (int)jarg2;
87204   arg3 = (int)jarg3;
87205   {
87206     try {
87207       try {
87208         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
87209       }
87210       catch(std::out_of_range &_e) {
87211         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87212         return ;
87213       }
87214       catch(std::invalid_argument &_e) {
87215         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87216         return ;
87217       }
87218
87219     } catch (std::out_of_range& e) {
87220       {
87221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87222       };
87223     } catch (std::exception& e) {
87224       {
87225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87226       };
87227     } catch (...) {
87228       {
87229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87230       };
87231     }
87232   }
87233 }
87234
87235
87236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
87237   void * jresult ;
87238   unsigned int *arg1 = 0 ;
87239   int arg2 ;
87240   unsigned int temp1 ;
87241   std::vector< unsigned int > *result = 0 ;
87242
87243   temp1 = (unsigned int)jarg1;
87244   arg1 = &temp1;
87245   arg2 = (int)jarg2;
87246   {
87247     try {
87248       try {
87249         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
87250       }
87251       catch(std::out_of_range &_e) {
87252         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87253         return 0;
87254       }
87255
87256     } catch (std::out_of_range& e) {
87257       {
87258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87259       };
87260     } catch (std::exception& e) {
87261       {
87262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87263       };
87264     } catch (...) {
87265       {
87266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87267       };
87268     }
87269   }
87270   jresult = (void *)result;
87271   return jresult;
87272 }
87273
87274
87275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
87276   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87277
87278   arg1 = (std::vector< unsigned int > *)jarg1;
87279   {
87280     try {
87281       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
87282     } catch (std::out_of_range& e) {
87283       {
87284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87285       };
87286     } catch (std::exception& e) {
87287       {
87288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87289       };
87290     } catch (...) {
87291       {
87292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87293       };
87294     }
87295   }
87296 }
87297
87298
87299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
87300   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87301   int arg2 ;
87302   int arg3 ;
87303
87304   arg1 = (std::vector< unsigned int > *)jarg1;
87305   arg2 = (int)jarg2;
87306   arg3 = (int)jarg3;
87307   {
87308     try {
87309       try {
87310         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
87311       }
87312       catch(std::out_of_range &_e) {
87313         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87314         return ;
87315       }
87316       catch(std::invalid_argument &_e) {
87317         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87318         return ;
87319       }
87320
87321     } catch (std::out_of_range& e) {
87322       {
87323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87324       };
87325     } catch (std::exception& e) {
87326       {
87327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87328       };
87329     } catch (...) {
87330       {
87331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87332       };
87333     }
87334   }
87335 }
87336
87337
87338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
87339   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87340   int arg2 ;
87341   std::vector< unsigned int > *arg3 = 0 ;
87342
87343   arg1 = (std::vector< unsigned int > *)jarg1;
87344   arg2 = (int)jarg2;
87345   arg3 = (std::vector< unsigned int > *)jarg3;
87346   if (!arg3) {
87347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87348     return ;
87349   }
87350   {
87351     try {
87352       try {
87353         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
87354       }
87355       catch(std::out_of_range &_e) {
87356         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87357         return ;
87358       }
87359
87360     } catch (std::out_of_range& e) {
87361       {
87362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87363       };
87364     } catch (std::exception& e) {
87365       {
87366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87367       };
87368     } catch (...) {
87369       {
87370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87371       };
87372     }
87373   }
87374 }
87375
87376
87377 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
87378   unsigned int jresult ;
87379   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87380   unsigned int *arg2 = 0 ;
87381   unsigned int temp2 ;
87382   bool result;
87383
87384   arg1 = (std::vector< unsigned int > *)jarg1;
87385   temp2 = (unsigned int)jarg2;
87386   arg2 = &temp2;
87387   {
87388     try {
87389       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
87390     } catch (std::out_of_range& e) {
87391       {
87392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87393       };
87394     } catch (std::exception& e) {
87395       {
87396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87397       };
87398     } catch (...) {
87399       {
87400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87401       };
87402     }
87403   }
87404   jresult = result;
87405   return jresult;
87406 }
87407
87408
87409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
87410   int jresult ;
87411   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87412   unsigned int *arg2 = 0 ;
87413   unsigned int temp2 ;
87414   int result;
87415
87416   arg1 = (std::vector< unsigned int > *)jarg1;
87417   temp2 = (unsigned int)jarg2;
87418   arg2 = &temp2;
87419   {
87420     try {
87421       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
87422     } catch (std::out_of_range& e) {
87423       {
87424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87425       };
87426     } catch (std::exception& e) {
87427       {
87428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87429       };
87430     } catch (...) {
87431       {
87432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87433       };
87434     }
87435   }
87436   jresult = result;
87437   return jresult;
87438 }
87439
87440
87441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
87442   int jresult ;
87443   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87444   unsigned int *arg2 = 0 ;
87445   unsigned int temp2 ;
87446   int result;
87447
87448   arg1 = (std::vector< unsigned int > *)jarg1;
87449   temp2 = (unsigned int)jarg2;
87450   arg2 = &temp2;
87451   {
87452     try {
87453       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
87454     } catch (std::out_of_range& e) {
87455       {
87456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87457       };
87458     } catch (std::exception& e) {
87459       {
87460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87461       };
87462     } catch (...) {
87463       {
87464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87465       };
87466     }
87467   }
87468   jresult = result;
87469   return jresult;
87470 }
87471
87472
87473 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
87474   unsigned int jresult ;
87475   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87476   unsigned int *arg2 = 0 ;
87477   unsigned int temp2 ;
87478   bool result;
87479
87480   arg1 = (std::vector< unsigned int > *)jarg1;
87481   temp2 = (unsigned int)jarg2;
87482   arg2 = &temp2;
87483   {
87484     try {
87485       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
87486     } catch (std::out_of_range& e) {
87487       {
87488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87489       };
87490     } catch (std::exception& e) {
87491       {
87492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87493       };
87494     } catch (...) {
87495       {
87496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87497       };
87498     }
87499   }
87500   jresult = result;
87501   return jresult;
87502 }
87503
87504
87505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
87506   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87507
87508   arg1 = (std::vector< unsigned int > *)jarg1;
87509   {
87510     try {
87511       delete arg1;
87512     } catch (std::out_of_range& e) {
87513       {
87514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87515       };
87516     } catch (std::exception& e) {
87517       {
87518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87519       };
87520     } catch (...) {
87521       {
87522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87523       };
87524     }
87525   }
87526 }
87527
87528
87529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
87530   void * jresult ;
87531   std::pair< unsigned int,Dali::Actor > *result = 0 ;
87532
87533   {
87534     try {
87535       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
87536     } catch (std::out_of_range& e) {
87537       {
87538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87539       };
87540     } catch (std::exception& e) {
87541       {
87542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87543       };
87544     } catch (...) {
87545       {
87546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87547       };
87548     }
87549   }
87550   jresult = (void *)result;
87551   return jresult;
87552 }
87553
87554
87555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
87556   void * jresult ;
87557   unsigned int arg1 ;
87558   Dali::Actor arg2 ;
87559   Dali::Actor *argp2 ;
87560   std::pair< unsigned int,Dali::Actor > *result = 0 ;
87561
87562   arg1 = (unsigned int)jarg1;
87563   argp2 = (Dali::Actor *)jarg2;
87564   if (!argp2) {
87565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87566     return 0;
87567   }
87568   arg2 = *argp2;
87569   {
87570     try {
87571       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
87572     } catch (std::out_of_range& e) {
87573       {
87574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87575       };
87576     } catch (std::exception& e) {
87577       {
87578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87579       };
87580     } catch (...) {
87581       {
87582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87583       };
87584     }
87585   }
87586   jresult = (void *)result;
87587   return jresult;
87588 }
87589
87590
87591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
87592   void * jresult ;
87593   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
87594   std::pair< unsigned int,Dali::Actor > *result = 0 ;
87595
87596   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87597   if (!arg1) {
87598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87599     return 0;
87600   }
87601   {
87602     try {
87603       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
87604     } catch (std::out_of_range& e) {
87605       {
87606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87607       };
87608     } catch (std::exception& e) {
87609       {
87610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87611       };
87612     } catch (...) {
87613       {
87614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87615       };
87616     }
87617   }
87618   jresult = (void *)result;
87619   return jresult;
87620 }
87621
87622
87623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
87624   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
87625   unsigned int arg2 ;
87626
87627   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87628   arg2 = (unsigned int)jarg2;
87629   if (arg1) (arg1)->first = arg2;
87630 }
87631
87632
87633 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
87634   unsigned int jresult ;
87635   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
87636   unsigned int result;
87637
87638   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87639   result = (unsigned int) ((arg1)->first);
87640   jresult = result;
87641   return jresult;
87642 }
87643
87644
87645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
87646   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
87647   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
87648
87649   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87650   arg2 = (Dali::Actor *)jarg2;
87651   if (arg1) (arg1)->second = *arg2;
87652 }
87653
87654
87655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
87656   void * jresult ;
87657   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
87658   Dali::Actor *result = 0 ;
87659
87660   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87661   result = (Dali::Actor *)& ((arg1)->second);
87662   jresult = (void *)result;
87663   return jresult;
87664 }
87665
87666
87667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
87668   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
87669
87670   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87671   {
87672     try {
87673       delete arg1;
87674     } catch (std::out_of_range& e) {
87675       {
87676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87677       };
87678     } catch (std::exception& e) {
87679       {
87680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87681       };
87682     } catch (...) {
87683       {
87684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87685       };
87686     }
87687   }
87688 }
87689
87690
87691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
87692   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87693
87694   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87695   {
87696     try {
87697       (arg1)->clear();
87698     } catch (std::out_of_range& e) {
87699       {
87700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87701       };
87702     } catch (std::exception& e) {
87703       {
87704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87705       };
87706     } catch (...) {
87707       {
87708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87709       };
87710     }
87711   }
87712 }
87713
87714
87715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
87716   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87717   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
87718
87719   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87720   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
87721   if (!arg2) {
87722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87723     return ;
87724   }
87725   {
87726     try {
87727       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
87728     } catch (std::out_of_range& e) {
87729       {
87730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87731       };
87732     } catch (std::exception& e) {
87733       {
87734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87735       };
87736     } catch (...) {
87737       {
87738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87739       };
87740     }
87741   }
87742 }
87743
87744
87745 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
87746   unsigned long jresult ;
87747   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87748   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
87749
87750   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87751   {
87752     try {
87753       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
87754     } catch (std::out_of_range& e) {
87755       {
87756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87757       };
87758     } catch (std::exception& e) {
87759       {
87760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87761       };
87762     } catch (...) {
87763       {
87764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87765       };
87766     }
87767   }
87768   jresult = (unsigned long)result;
87769   return jresult;
87770 }
87771
87772
87773 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
87774   unsigned long jresult ;
87775   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87776   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
87777
87778   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87779   {
87780     try {
87781       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
87782     } catch (std::out_of_range& e) {
87783       {
87784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87785       };
87786     } catch (std::exception& e) {
87787       {
87788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87789       };
87790     } catch (...) {
87791       {
87792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87793       };
87794     }
87795   }
87796   jresult = (unsigned long)result;
87797   return jresult;
87798 }
87799
87800
87801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
87802   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87803   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
87804
87805   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87806   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
87807   {
87808     try {
87809       (arg1)->reserve(arg2);
87810     } catch (std::out_of_range& e) {
87811       {
87812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87813       };
87814     } catch (std::exception& e) {
87815       {
87816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87817       };
87818     } catch (...) {
87819       {
87820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87821       };
87822     }
87823   }
87824 }
87825
87826
87827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
87828   void * jresult ;
87829   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87830
87831   {
87832     try {
87833       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
87834     } catch (std::out_of_range& e) {
87835       {
87836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87837       };
87838     } catch (std::exception& e) {
87839       {
87840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87841       };
87842     } catch (...) {
87843       {
87844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87845       };
87846     }
87847   }
87848   jresult = (void *)result;
87849   return jresult;
87850 }
87851
87852
87853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
87854   void * jresult ;
87855   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
87856   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87857
87858   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87859   if (!arg1) {
87860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
87861     return 0;
87862   }
87863   {
87864     try {
87865       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);
87866     } catch (std::out_of_range& e) {
87867       {
87868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87869       };
87870     } catch (std::exception& e) {
87871       {
87872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87873       };
87874     } catch (...) {
87875       {
87876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87877       };
87878     }
87879   }
87880   jresult = (void *)result;
87881   return jresult;
87882 }
87883
87884
87885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
87886   void * jresult ;
87887   int arg1 ;
87888   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87889
87890   arg1 = (int)jarg1;
87891   {
87892     try {
87893       try {
87894         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);
87895       }
87896       catch(std::out_of_range &_e) {
87897         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87898         return 0;
87899       }
87900
87901     } catch (std::out_of_range& e) {
87902       {
87903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87904       };
87905     } catch (std::exception& e) {
87906       {
87907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87908       };
87909     } catch (...) {
87910       {
87911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87912       };
87913     }
87914   }
87915   jresult = (void *)result;
87916   return jresult;
87917 }
87918
87919
87920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
87921   void * jresult ;
87922   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87923   int arg2 ;
87924   std::pair< unsigned int,Dali::Actor > result;
87925
87926   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87927   arg2 = (int)jarg2;
87928   {
87929     try {
87930       try {
87931         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
87932       }
87933       catch(std::out_of_range &_e) {
87934         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87935         return 0;
87936       }
87937
87938     } catch (std::out_of_range& e) {
87939       {
87940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87941       };
87942     } catch (std::exception& e) {
87943       {
87944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87945       };
87946     } catch (...) {
87947       {
87948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87949       };
87950     }
87951   }
87952   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
87953   return jresult;
87954 }
87955
87956
87957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
87958   void * jresult ;
87959   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87960   int arg2 ;
87961   std::pair< unsigned int,Dali::Actor > *result = 0 ;
87962
87963   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87964   arg2 = (int)jarg2;
87965   {
87966     try {
87967       try {
87968         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
87969       }
87970       catch(std::out_of_range &_e) {
87971         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87972         return 0;
87973       }
87974
87975     } catch (std::out_of_range& e) {
87976       {
87977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87978       };
87979     } catch (std::exception& e) {
87980       {
87981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87982       };
87983     } catch (...) {
87984       {
87985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87986       };
87987     }
87988   }
87989   jresult = (void *)result;
87990   return jresult;
87991 }
87992
87993
87994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
87995   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87996   int arg2 ;
87997   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
87998
87999   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88000   arg2 = (int)jarg2;
88001   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
88002   if (!arg3) {
88003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88004     return ;
88005   }
88006   {
88007     try {
88008       try {
88009         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);
88010       }
88011       catch(std::out_of_range &_e) {
88012         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88013         return ;
88014       }
88015
88016     } catch (std::out_of_range& e) {
88017       {
88018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88019       };
88020     } catch (std::exception& e) {
88021       {
88022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88023       };
88024     } catch (...) {
88025       {
88026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88027       };
88028     }
88029   }
88030 }
88031
88032
88033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
88034   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88035   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
88036
88037   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88038   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
88039   if (!arg2) {
88040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88041     return ;
88042   }
88043   {
88044     try {
88045       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);
88046     } catch (std::out_of_range& e) {
88047       {
88048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88049       };
88050     } catch (std::exception& e) {
88051       {
88052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88053       };
88054     } catch (...) {
88055       {
88056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88057       };
88058     }
88059   }
88060 }
88061
88062
88063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
88064   void * jresult ;
88065   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88066   int arg2 ;
88067   int arg3 ;
88068   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88069
88070   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88071   arg2 = (int)jarg2;
88072   arg3 = (int)jarg3;
88073   {
88074     try {
88075       try {
88076         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);
88077       }
88078       catch(std::out_of_range &_e) {
88079         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88080         return 0;
88081       }
88082       catch(std::invalid_argument &_e) {
88083         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88084         return 0;
88085       }
88086
88087     } catch (std::out_of_range& e) {
88088       {
88089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88090       };
88091     } catch (std::exception& e) {
88092       {
88093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88094       };
88095     } catch (...) {
88096       {
88097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88098       };
88099     }
88100   }
88101   jresult = (void *)result;
88102   return jresult;
88103 }
88104
88105
88106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
88107   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88108   int arg2 ;
88109   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
88110
88111   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88112   arg2 = (int)jarg2;
88113   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
88114   if (!arg3) {
88115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88116     return ;
88117   }
88118   {
88119     try {
88120       try {
88121         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);
88122       }
88123       catch(std::out_of_range &_e) {
88124         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88125         return ;
88126       }
88127
88128     } catch (std::out_of_range& e) {
88129       {
88130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88131       };
88132     } catch (std::exception& e) {
88133       {
88134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88135       };
88136     } catch (...) {
88137       {
88138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88139       };
88140     }
88141   }
88142 }
88143
88144
88145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
88146   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88147   int arg2 ;
88148   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
88149
88150   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88151   arg2 = (int)jarg2;
88152   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
88153   if (!arg3) {
88154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88155     return ;
88156   }
88157   {
88158     try {
88159       try {
88160         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);
88161       }
88162       catch(std::out_of_range &_e) {
88163         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88164         return ;
88165       }
88166
88167     } catch (std::out_of_range& e) {
88168       {
88169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88170       };
88171     } catch (std::exception& e) {
88172       {
88173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88174       };
88175     } catch (...) {
88176       {
88177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88178       };
88179     }
88180   }
88181 }
88182
88183
88184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
88185   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88186   int arg2 ;
88187
88188   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88189   arg2 = (int)jarg2;
88190   {
88191     try {
88192       try {
88193         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
88194       }
88195       catch(std::out_of_range &_e) {
88196         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88197         return ;
88198       }
88199
88200     } catch (std::out_of_range& e) {
88201       {
88202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88203       };
88204     } catch (std::exception& e) {
88205       {
88206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88207       };
88208     } catch (...) {
88209       {
88210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88211       };
88212     }
88213   }
88214 }
88215
88216
88217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
88218   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88219   int arg2 ;
88220   int arg3 ;
88221
88222   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88223   arg2 = (int)jarg2;
88224   arg3 = (int)jarg3;
88225   {
88226     try {
88227       try {
88228         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
88229       }
88230       catch(std::out_of_range &_e) {
88231         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88232         return ;
88233       }
88234       catch(std::invalid_argument &_e) {
88235         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88236         return ;
88237       }
88238
88239     } catch (std::out_of_range& e) {
88240       {
88241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88242       };
88243     } catch (std::exception& e) {
88244       {
88245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88246       };
88247     } catch (...) {
88248       {
88249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88250       };
88251     }
88252   }
88253 }
88254
88255
88256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
88257   void * jresult ;
88258   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
88259   int arg2 ;
88260   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88261
88262   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88263   if (!arg1) {
88264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88265     return 0;
88266   }
88267   arg2 = (int)jarg2;
88268   {
88269     try {
88270       try {
88271         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);
88272       }
88273       catch(std::out_of_range &_e) {
88274         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88275         return 0;
88276       }
88277
88278     } catch (std::out_of_range& e) {
88279       {
88280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88281       };
88282     } catch (std::exception& e) {
88283       {
88284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88285       };
88286     } catch (...) {
88287       {
88288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88289       };
88290     }
88291   }
88292   jresult = (void *)result;
88293   return jresult;
88294 }
88295
88296
88297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
88298   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88299
88300   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88301   {
88302     try {
88303       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
88304     } catch (std::out_of_range& e) {
88305       {
88306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88307       };
88308     } catch (std::exception& e) {
88309       {
88310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88311       };
88312     } catch (...) {
88313       {
88314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88315       };
88316     }
88317   }
88318 }
88319
88320
88321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
88322   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88323   int arg2 ;
88324   int arg3 ;
88325
88326   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88327   arg2 = (int)jarg2;
88328   arg3 = (int)jarg3;
88329   {
88330     try {
88331       try {
88332         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
88333       }
88334       catch(std::out_of_range &_e) {
88335         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88336         return ;
88337       }
88338       catch(std::invalid_argument &_e) {
88339         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88340         return ;
88341       }
88342
88343     } catch (std::out_of_range& e) {
88344       {
88345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88346       };
88347     } catch (std::exception& e) {
88348       {
88349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88350       };
88351     } catch (...) {
88352       {
88353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88354       };
88355     }
88356   }
88357 }
88358
88359
88360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
88361   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88362   int arg2 ;
88363   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
88364
88365   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88366   arg2 = (int)jarg2;
88367   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
88368   if (!arg3) {
88369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88370     return ;
88371   }
88372   {
88373     try {
88374       try {
88375         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);
88376       }
88377       catch(std::out_of_range &_e) {
88378         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88379         return ;
88380       }
88381
88382     } catch (std::out_of_range& e) {
88383       {
88384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88385       };
88386     } catch (std::exception& e) {
88387       {
88388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88389       };
88390     } catch (...) {
88391       {
88392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88393       };
88394     }
88395   }
88396 }
88397
88398
88399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
88400   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88401
88402   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88403   {
88404     try {
88405       delete arg1;
88406     } catch (std::out_of_range& e) {
88407       {
88408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88409       };
88410     } catch (std::exception& e) {
88411       {
88412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88413       };
88414     } catch (...) {
88415       {
88416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88417       };
88418     }
88419   }
88420 }
88421
88422
88423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
88424   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88425
88426   arg1 = (std::vector< Dali::Actor > *)jarg1;
88427   {
88428     try {
88429       (arg1)->clear();
88430     } catch (std::out_of_range& e) {
88431       {
88432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88433       };
88434     } catch (std::exception& e) {
88435       {
88436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88437       };
88438     } catch (...) {
88439       {
88440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88441       };
88442     }
88443   }
88444 }
88445
88446
88447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
88448   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88449   Dali::Actor *arg2 = 0 ;
88450
88451   arg1 = (std::vector< Dali::Actor > *)jarg1;
88452   arg2 = (Dali::Actor *)jarg2;
88453   if (!arg2) {
88454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
88455     return ;
88456   }
88457   {
88458     try {
88459       (arg1)->push_back((Dali::Actor const &)*arg2);
88460     } catch (std::out_of_range& e) {
88461       {
88462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88463       };
88464     } catch (std::exception& e) {
88465       {
88466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88467       };
88468     } catch (...) {
88469       {
88470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88471       };
88472     }
88473   }
88474 }
88475
88476
88477 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
88478   unsigned long jresult ;
88479   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88480   std::vector< Dali::Actor >::size_type result;
88481
88482   arg1 = (std::vector< Dali::Actor > *)jarg1;
88483   {
88484     try {
88485       result = ((std::vector< Dali::Actor > const *)arg1)->size();
88486     } catch (std::out_of_range& e) {
88487       {
88488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88489       };
88490     } catch (std::exception& e) {
88491       {
88492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88493       };
88494     } catch (...) {
88495       {
88496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88497       };
88498     }
88499   }
88500   jresult = (unsigned long)result;
88501   return jresult;
88502 }
88503
88504
88505 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
88506   unsigned long jresult ;
88507   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88508   std::vector< Dali::Actor >::size_type result;
88509
88510   arg1 = (std::vector< Dali::Actor > *)jarg1;
88511   {
88512     try {
88513       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
88514     } catch (std::out_of_range& e) {
88515       {
88516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88517       };
88518     } catch (std::exception& e) {
88519       {
88520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88521       };
88522     } catch (...) {
88523       {
88524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88525       };
88526     }
88527   }
88528   jresult = (unsigned long)result;
88529   return jresult;
88530 }
88531
88532
88533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
88534   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88535   std::vector< Dali::Actor >::size_type arg2 ;
88536
88537   arg1 = (std::vector< Dali::Actor > *)jarg1;
88538   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
88539   {
88540     try {
88541       (arg1)->reserve(arg2);
88542     } catch (std::out_of_range& e) {
88543       {
88544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88545       };
88546     } catch (std::exception& e) {
88547       {
88548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88549       };
88550     } catch (...) {
88551       {
88552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88553       };
88554     }
88555   }
88556 }
88557
88558
88559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
88560   void * jresult ;
88561   std::vector< Dali::Actor > *result = 0 ;
88562
88563   {
88564     try {
88565       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
88566     } catch (std::out_of_range& e) {
88567       {
88568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88569       };
88570     } catch (std::exception& e) {
88571       {
88572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88573       };
88574     } catch (...) {
88575       {
88576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88577       };
88578     }
88579   }
88580   jresult = (void *)result;
88581   return jresult;
88582 }
88583
88584
88585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
88586   void * jresult ;
88587   std::vector< Dali::Actor > *arg1 = 0 ;
88588   std::vector< Dali::Actor > *result = 0 ;
88589
88590   arg1 = (std::vector< Dali::Actor > *)jarg1;
88591   if (!arg1) {
88592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
88593     return 0;
88594   }
88595   {
88596     try {
88597       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
88598     } catch (std::out_of_range& e) {
88599       {
88600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88601       };
88602     } catch (std::exception& e) {
88603       {
88604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88605       };
88606     } catch (...) {
88607       {
88608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88609       };
88610     }
88611   }
88612   jresult = (void *)result;
88613   return jresult;
88614 }
88615
88616
88617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
88618   void * jresult ;
88619   int arg1 ;
88620   std::vector< Dali::Actor > *result = 0 ;
88621
88622   arg1 = (int)jarg1;
88623   {
88624     try {
88625       try {
88626         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
88627       }
88628       catch(std::out_of_range &_e) {
88629         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88630         return 0;
88631       }
88632
88633     } catch (std::out_of_range& e) {
88634       {
88635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88636       };
88637     } catch (std::exception& e) {
88638       {
88639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88640       };
88641     } catch (...) {
88642       {
88643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88644       };
88645     }
88646   }
88647   jresult = (void *)result;
88648   return jresult;
88649 }
88650
88651
88652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
88653   void * jresult ;
88654   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88655   int arg2 ;
88656   Dali::Actor result;
88657
88658   arg1 = (std::vector< Dali::Actor > *)jarg1;
88659   arg2 = (int)jarg2;
88660   {
88661     try {
88662       try {
88663         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
88664       }
88665       catch(std::out_of_range &_e) {
88666         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88667         return 0;
88668       }
88669
88670     } catch (std::out_of_range& e) {
88671       {
88672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88673       };
88674     } catch (std::exception& e) {
88675       {
88676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88677       };
88678     } catch (...) {
88679       {
88680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88681       };
88682     }
88683   }
88684   jresult = new Dali::Actor((const Dali::Actor &)result);
88685   return jresult;
88686 }
88687
88688
88689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
88690   void * jresult ;
88691   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88692   int arg2 ;
88693   Dali::Actor *result = 0 ;
88694
88695   arg1 = (std::vector< Dali::Actor > *)jarg1;
88696   arg2 = (int)jarg2;
88697   {
88698     try {
88699       try {
88700         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
88701       }
88702       catch(std::out_of_range &_e) {
88703         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88704         return 0;
88705       }
88706
88707     } catch (std::out_of_range& e) {
88708       {
88709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88710       };
88711     } catch (std::exception& e) {
88712       {
88713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88714       };
88715     } catch (...) {
88716       {
88717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88718       };
88719     }
88720   }
88721   jresult = (void *)result;
88722   return jresult;
88723 }
88724
88725
88726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
88727   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88728   int arg2 ;
88729   Dali::Actor *arg3 = 0 ;
88730
88731   arg1 = (std::vector< Dali::Actor > *)jarg1;
88732   arg2 = (int)jarg2;
88733   arg3 = (Dali::Actor *)jarg3;
88734   if (!arg3) {
88735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
88736     return ;
88737   }
88738   {
88739     try {
88740       try {
88741         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
88742       }
88743       catch(std::out_of_range &_e) {
88744         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88745         return ;
88746       }
88747
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_ActorContainer_AddRange(void * jarg1, void * jarg2) {
88766   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88767   std::vector< Dali::Actor > *arg2 = 0 ;
88768
88769   arg1 = (std::vector< Dali::Actor > *)jarg1;
88770   arg2 = (std::vector< Dali::Actor > *)jarg2;
88771   if (!arg2) {
88772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
88773     return ;
88774   }
88775   {
88776     try {
88777       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
88778     } catch (std::out_of_range& e) {
88779       {
88780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88781       };
88782     } catch (std::exception& e) {
88783       {
88784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88785       };
88786     } catch (...) {
88787       {
88788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88789       };
88790     }
88791   }
88792 }
88793
88794
88795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
88796   void * jresult ;
88797   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88798   int arg2 ;
88799   int arg3 ;
88800   std::vector< Dali::Actor > *result = 0 ;
88801
88802   arg1 = (std::vector< Dali::Actor > *)jarg1;
88803   arg2 = (int)jarg2;
88804   arg3 = (int)jarg3;
88805   {
88806     try {
88807       try {
88808         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
88809       }
88810       catch(std::out_of_range &_e) {
88811         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88812         return 0;
88813       }
88814       catch(std::invalid_argument &_e) {
88815         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88816         return 0;
88817       }
88818
88819     } catch (std::out_of_range& e) {
88820       {
88821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88822       };
88823     } catch (std::exception& e) {
88824       {
88825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88826       };
88827     } catch (...) {
88828       {
88829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88830       };
88831     }
88832   }
88833   jresult = (void *)result;
88834   return jresult;
88835 }
88836
88837
88838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
88839   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88840   int arg2 ;
88841   Dali::Actor *arg3 = 0 ;
88842
88843   arg1 = (std::vector< Dali::Actor > *)jarg1;
88844   arg2 = (int)jarg2;
88845   arg3 = (Dali::Actor *)jarg3;
88846   if (!arg3) {
88847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
88848     return ;
88849   }
88850   {
88851     try {
88852       try {
88853         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
88854       }
88855       catch(std::out_of_range &_e) {
88856         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88857         return ;
88858       }
88859
88860     } catch (std::out_of_range& e) {
88861       {
88862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88863       };
88864     } catch (std::exception& e) {
88865       {
88866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88867       };
88868     } catch (...) {
88869       {
88870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88871       };
88872     }
88873   }
88874 }
88875
88876
88877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
88878   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88879   int arg2 ;
88880   std::vector< Dali::Actor > *arg3 = 0 ;
88881
88882   arg1 = (std::vector< Dali::Actor > *)jarg1;
88883   arg2 = (int)jarg2;
88884   arg3 = (std::vector< Dali::Actor > *)jarg3;
88885   if (!arg3) {
88886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
88887     return ;
88888   }
88889   {
88890     try {
88891       try {
88892         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
88893       }
88894       catch(std::out_of_range &_e) {
88895         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88896         return ;
88897       }
88898
88899     } catch (std::out_of_range& e) {
88900       {
88901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88902       };
88903     } catch (std::exception& e) {
88904       {
88905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88906       };
88907     } catch (...) {
88908       {
88909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88910       };
88911     }
88912   }
88913 }
88914
88915
88916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
88917   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88918   int arg2 ;
88919
88920   arg1 = (std::vector< Dali::Actor > *)jarg1;
88921   arg2 = (int)jarg2;
88922   {
88923     try {
88924       try {
88925         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
88926       }
88927       catch(std::out_of_range &_e) {
88928         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88929         return ;
88930       }
88931
88932     } catch (std::out_of_range& e) {
88933       {
88934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88935       };
88936     } catch (std::exception& e) {
88937       {
88938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88939       };
88940     } catch (...) {
88941       {
88942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88943       };
88944     }
88945   }
88946 }
88947
88948
88949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
88950   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88951   int arg2 ;
88952   int arg3 ;
88953
88954   arg1 = (std::vector< Dali::Actor > *)jarg1;
88955   arg2 = (int)jarg2;
88956   arg3 = (int)jarg3;
88957   {
88958     try {
88959       try {
88960         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
88961       }
88962       catch(std::out_of_range &_e) {
88963         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88964         return ;
88965       }
88966       catch(std::invalid_argument &_e) {
88967         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88968         return ;
88969       }
88970
88971     } catch (std::out_of_range& e) {
88972       {
88973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88974       };
88975     } catch (std::exception& e) {
88976       {
88977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88978       };
88979     } catch (...) {
88980       {
88981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88982       };
88983     }
88984   }
88985 }
88986
88987
88988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
88989   void * jresult ;
88990   Dali::Actor *arg1 = 0 ;
88991   int arg2 ;
88992   std::vector< Dali::Actor > *result = 0 ;
88993
88994   arg1 = (Dali::Actor *)jarg1;
88995   if (!arg1) {
88996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
88997     return 0;
88998   }
88999   arg2 = (int)jarg2;
89000   {
89001     try {
89002       try {
89003         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
89004       }
89005       catch(std::out_of_range &_e) {
89006         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89007         return 0;
89008       }
89009
89010     } catch (std::out_of_range& e) {
89011       {
89012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89013       };
89014     } catch (std::exception& e) {
89015       {
89016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89017       };
89018     } catch (...) {
89019       {
89020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89021       };
89022     }
89023   }
89024   jresult = (void *)result;
89025   return jresult;
89026 }
89027
89028
89029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
89030   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89031
89032   arg1 = (std::vector< Dali::Actor > *)jarg1;
89033   {
89034     try {
89035       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
89036     } catch (std::out_of_range& e) {
89037       {
89038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89039       };
89040     } catch (std::exception& e) {
89041       {
89042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89043       };
89044     } catch (...) {
89045       {
89046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89047       };
89048     }
89049   }
89050 }
89051
89052
89053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
89054   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89055   int arg2 ;
89056   int arg3 ;
89057
89058   arg1 = (std::vector< Dali::Actor > *)jarg1;
89059   arg2 = (int)jarg2;
89060   arg3 = (int)jarg3;
89061   {
89062     try {
89063       try {
89064         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
89065       }
89066       catch(std::out_of_range &_e) {
89067         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89068         return ;
89069       }
89070       catch(std::invalid_argument &_e) {
89071         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89072         return ;
89073       }
89074
89075     } catch (std::out_of_range& e) {
89076       {
89077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89078       };
89079     } catch (std::exception& e) {
89080       {
89081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89082       };
89083     } catch (...) {
89084       {
89085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89086       };
89087     }
89088   }
89089 }
89090
89091
89092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
89093   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89094   int arg2 ;
89095   std::vector< Dali::Actor > *arg3 = 0 ;
89096
89097   arg1 = (std::vector< Dali::Actor > *)jarg1;
89098   arg2 = (int)jarg2;
89099   arg3 = (std::vector< Dali::Actor > *)jarg3;
89100   if (!arg3) {
89101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89102     return ;
89103   }
89104   {
89105     try {
89106       try {
89107         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
89108       }
89109       catch(std::out_of_range &_e) {
89110         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89111         return ;
89112       }
89113
89114     } catch (std::out_of_range& e) {
89115       {
89116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89117       };
89118     } catch (std::exception& e) {
89119       {
89120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89121       };
89122     } catch (...) {
89123       {
89124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89125       };
89126     }
89127   }
89128 }
89129
89130
89131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
89132   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89133
89134   arg1 = (std::vector< Dali::Actor > *)jarg1;
89135   {
89136     try {
89137       delete arg1;
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 unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
89156   unsigned int jresult ;
89157   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89158   bool result;
89159
89160   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89161   {
89162     try {
89163       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
89164     } catch (std::out_of_range& e) {
89165       {
89166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89167       };
89168     } catch (std::exception& e) {
89169       {
89170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89171       };
89172     } catch (...) {
89173       {
89174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89175       };
89176     }
89177   }
89178   jresult = result;
89179   return jresult;
89180 }
89181
89182
89183 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
89184   unsigned long jresult ;
89185   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89186   std::size_t result;
89187
89188   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89189   {
89190     try {
89191       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
89192     } catch (std::out_of_range& e) {
89193       {
89194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89195       };
89196     } catch (std::exception& e) {
89197       {
89198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89199       };
89200     } catch (...) {
89201       {
89202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89203       };
89204     }
89205   }
89206   jresult = (unsigned long)result;
89207   return jresult;
89208 }
89209
89210
89211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
89212   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89213   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
89214
89215   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89216   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
89217   {
89218     try {
89219       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
89220     } catch (std::out_of_range& e) {
89221       {
89222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89223       };
89224     } catch (std::exception& e) {
89225       {
89226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89227       };
89228     } catch (...) {
89229       {
89230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89231       };
89232     }
89233   }
89234 }
89235
89236
89237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
89238   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89239   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
89240
89241   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89242   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
89243   {
89244     try {
89245       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
89246     } catch (std::out_of_range& e) {
89247       {
89248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89249       };
89250     } catch (std::exception& e) {
89251       {
89252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89253       };
89254     } catch (...) {
89255       {
89256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89257       };
89258     }
89259   }
89260 }
89261
89262
89263 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
89264   unsigned int jresult ;
89265   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89266   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
89267   bool result;
89268
89269   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89270   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
89271   if (!arg2) {
89272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
89273     return 0;
89274   }
89275   {
89276     try {
89277       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
89278     } catch (std::out_of_range& e) {
89279       {
89280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89281       };
89282     } catch (std::exception& e) {
89283       {
89284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89285       };
89286     } catch (...) {
89287       {
89288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89289       };
89290     }
89291   }
89292   jresult = result;
89293   return jresult;
89294 }
89295
89296
89297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
89298   void * jresult ;
89299   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
89300
89301   {
89302     try {
89303       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
89304     } catch (std::out_of_range& e) {
89305       {
89306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89307       };
89308     } catch (std::exception& e) {
89309       {
89310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89311       };
89312     } catch (...) {
89313       {
89314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89315       };
89316     }
89317   }
89318   jresult = (void *)result;
89319   return jresult;
89320 }
89321
89322
89323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
89324   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89325
89326   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89327   {
89328     try {
89329       delete arg1;
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 unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
89348   unsigned int jresult ;
89349   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89350   bool result;
89351
89352   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89353   {
89354     try {
89355       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);
89356     } catch (std::out_of_range& e) {
89357       {
89358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89359       };
89360     } catch (std::exception& e) {
89361       {
89362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89363       };
89364     } catch (...) {
89365       {
89366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89367       };
89368     }
89369   }
89370   jresult = result;
89371   return jresult;
89372 }
89373
89374
89375 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
89376   unsigned long jresult ;
89377   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89378   std::size_t result;
89379
89380   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89381   {
89382     try {
89383       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);
89384     } catch (std::out_of_range& e) {
89385       {
89386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89387       };
89388     } catch (std::exception& e) {
89389       {
89390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89391       };
89392     } catch (...) {
89393       {
89394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89395       };
89396     }
89397   }
89398   jresult = (unsigned long)result;
89399   return jresult;
89400 }
89401
89402
89403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
89404   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89405   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
89406
89407   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89408   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
89409   {
89410     try {
89411       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
89412     } catch (std::out_of_range& e) {
89413       {
89414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89415       };
89416     } catch (std::exception& e) {
89417       {
89418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89419       };
89420     } catch (...) {
89421       {
89422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89423       };
89424     }
89425   }
89426 }
89427
89428
89429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
89430   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89431   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
89432
89433   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89434   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
89435   {
89436     try {
89437       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
89438     } catch (std::out_of_range& e) {
89439       {
89440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89441       };
89442     } catch (std::exception& e) {
89443       {
89444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89445       };
89446     } catch (...) {
89447       {
89448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89449       };
89450     }
89451   }
89452 }
89453
89454
89455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
89456   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89457   Dali::Actor arg2 ;
89458   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
89459   Dali::Actor *argp2 ;
89460
89461   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89462   argp2 = (Dali::Actor *)jarg2;
89463   if (!argp2) {
89464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89465     return ;
89466   }
89467   arg2 = *argp2;
89468   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
89469   {
89470     try {
89471       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
89472     } catch (std::out_of_range& e) {
89473       {
89474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89475       };
89476     } catch (std::exception& e) {
89477       {
89478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89479       };
89480     } catch (...) {
89481       {
89482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89483       };
89484     }
89485   }
89486 }
89487
89488
89489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
89490   void * jresult ;
89491   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
89492
89493   {
89494     try {
89495       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
89496     } catch (std::out_of_range& e) {
89497       {
89498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89499       };
89500     } catch (std::exception& e) {
89501       {
89502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89503       };
89504     } catch (...) {
89505       {
89506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89507       };
89508     }
89509   }
89510   jresult = (void *)result;
89511   return jresult;
89512 }
89513
89514
89515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
89516   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89517
89518   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89519   {
89520     try {
89521       delete arg1;
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 unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
89540   unsigned int jresult ;
89541   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89542   bool result;
89543
89544   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89545   {
89546     try {
89547       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
89548     } catch (std::out_of_range& e) {
89549       {
89550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89551       };
89552     } catch (std::exception& e) {
89553       {
89554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89555       };
89556     } catch (...) {
89557       {
89558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89559       };
89560     }
89561   }
89562   jresult = result;
89563   return jresult;
89564 }
89565
89566
89567 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
89568   unsigned long jresult ;
89569   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89570   std::size_t result;
89571
89572   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89573   {
89574     try {
89575       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
89576     } catch (std::out_of_range& e) {
89577       {
89578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89579       };
89580     } catch (std::exception& e) {
89581       {
89582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89583       };
89584     } catch (...) {
89585       {
89586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89587       };
89588     }
89589   }
89590   jresult = (unsigned long)result;
89591   return jresult;
89592 }
89593
89594
89595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
89596   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89597   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
89598
89599   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89600   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
89601   {
89602     try {
89603       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
89604     } catch (std::out_of_range& e) {
89605       {
89606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89607       };
89608     } catch (std::exception& e) {
89609       {
89610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89611       };
89612     } catch (...) {
89613       {
89614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89615       };
89616     }
89617   }
89618 }
89619
89620
89621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
89622   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89623   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
89624
89625   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89626   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
89627   {
89628     try {
89629       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
89630     } catch (std::out_of_range& e) {
89631       {
89632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89633       };
89634     } catch (std::exception& e) {
89635       {
89636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89637       };
89638     } catch (...) {
89639       {
89640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89641       };
89642     }
89643   }
89644 }
89645
89646
89647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
89648   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89649   Dali::Actor arg2 ;
89650   Dali::Actor arg3 ;
89651   Dali::Actor *argp2 ;
89652   Dali::Actor *argp3 ;
89653
89654   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89655   argp2 = (Dali::Actor *)jarg2;
89656   if (!argp2) {
89657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89658     return ;
89659   }
89660   arg2 = *argp2;
89661   argp3 = (Dali::Actor *)jarg3;
89662   if (!argp3) {
89663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89664     return ;
89665   }
89666   arg3 = *argp3;
89667   {
89668     try {
89669       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
89670     } catch (std::out_of_range& e) {
89671       {
89672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89673       };
89674     } catch (std::exception& e) {
89675       {
89676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89677       };
89678     } catch (...) {
89679       {
89680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89681       };
89682     }
89683   }
89684 }
89685
89686
89687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
89688   void * jresult ;
89689   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
89690
89691   {
89692     try {
89693       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
89694     } catch (std::out_of_range& e) {
89695       {
89696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89697       };
89698     } catch (std::exception& e) {
89699       {
89700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89701       };
89702     } catch (...) {
89703       {
89704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89705       };
89706     }
89707   }
89708   jresult = (void *)result;
89709   return jresult;
89710 }
89711
89712
89713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
89714   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89715
89716   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89717   {
89718     try {
89719       delete arg1;
89720     } catch (std::out_of_range& e) {
89721       {
89722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89723       };
89724     } catch (std::exception& e) {
89725       {
89726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89727       };
89728     } catch (...) {
89729       {
89730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89731       };
89732     }
89733   }
89734 }
89735
89736
89737 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
89738   unsigned int jresult ;
89739   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89740   bool result;
89741
89742   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89743   {
89744     try {
89745       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
89746     } catch (std::out_of_range& e) {
89747       {
89748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89749       };
89750     } catch (std::exception& e) {
89751       {
89752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89753       };
89754     } catch (...) {
89755       {
89756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89757       };
89758     }
89759   }
89760   jresult = result;
89761   return jresult;
89762 }
89763
89764
89765 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
89766   unsigned long jresult ;
89767   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89768   std::size_t result;
89769
89770   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89771   {
89772     try {
89773       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
89774     } catch (std::out_of_range& e) {
89775       {
89776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89777       };
89778     } catch (std::exception& e) {
89779       {
89780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89781       };
89782     } catch (...) {
89783       {
89784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89785       };
89786     }
89787   }
89788   jresult = (unsigned long)result;
89789   return jresult;
89790 }
89791
89792
89793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
89794   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89795   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
89796
89797   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89798   arg2 = (void (*)(Dali::Actor,bool))jarg2;
89799   {
89800     try {
89801       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
89802     } catch (std::out_of_range& e) {
89803       {
89804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89805       };
89806     } catch (std::exception& e) {
89807       {
89808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89809       };
89810     } catch (...) {
89811       {
89812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89813       };
89814     }
89815   }
89816 }
89817
89818
89819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
89820   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89821   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
89822
89823   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89824   arg2 = (void (*)(Dali::Actor,bool))jarg2;
89825   {
89826     try {
89827       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
89828     } catch (std::out_of_range& e) {
89829       {
89830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89831       };
89832     } catch (std::exception& e) {
89833       {
89834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89835       };
89836     } catch (...) {
89837       {
89838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89839       };
89840     }
89841   }
89842 }
89843
89844
89845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
89846   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89847   Dali::Actor arg2 ;
89848   bool arg3 ;
89849   Dali::Actor *argp2 ;
89850
89851   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89852   argp2 = (Dali::Actor *)jarg2;
89853   if (!argp2) {
89854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89855     return ;
89856   }
89857   arg2 = *argp2;
89858   arg3 = jarg3 ? true : false;
89859   {
89860     try {
89861       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
89862     } catch (std::out_of_range& e) {
89863       {
89864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89865       };
89866     } catch (std::exception& e) {
89867       {
89868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89869       };
89870     } catch (...) {
89871       {
89872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89873       };
89874     }
89875   }
89876 }
89877
89878
89879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
89880   void * jresult ;
89881   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
89882
89883   {
89884     try {
89885       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
89886     } catch (std::out_of_range& e) {
89887       {
89888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89889       };
89890     } catch (std::exception& e) {
89891       {
89892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89893       };
89894     } catch (...) {
89895       {
89896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89897       };
89898     }
89899   }
89900   jresult = (void *)result;
89901   return jresult;
89902 }
89903
89904
89905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
89906   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89907
89908   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89909   {
89910     try {
89911       delete arg1;
89912     } catch (std::out_of_range& e) {
89913       {
89914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89915       };
89916     } catch (std::exception& e) {
89917       {
89918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89919       };
89920     } catch (...) {
89921       {
89922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89923       };
89924     }
89925   }
89926 }
89927
89928
89929 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
89930   unsigned int jresult ;
89931   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89932   bool result;
89933
89934   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89935   {
89936     try {
89937       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);
89938     } catch (std::out_of_range& e) {
89939       {
89940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89941       };
89942     } catch (std::exception& e) {
89943       {
89944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89945       };
89946     } catch (...) {
89947       {
89948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89949       };
89950     }
89951   }
89952   jresult = result;
89953   return jresult;
89954 }
89955
89956
89957 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
89958   unsigned long jresult ;
89959   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89960   std::size_t result;
89961
89962   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89963   {
89964     try {
89965       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);
89966     } catch (std::out_of_range& e) {
89967       {
89968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89969       };
89970     } catch (std::exception& e) {
89971       {
89972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89973       };
89974     } catch (...) {
89975       {
89976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89977       };
89978     }
89979   }
89980   jresult = (unsigned long)result;
89981   return jresult;
89982 }
89983
89984
89985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
89986   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89987   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
89988
89989   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89990   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
89991   {
89992     try {
89993       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
89994     } catch (std::out_of_range& e) {
89995       {
89996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89997       };
89998     } catch (std::exception& e) {
89999       {
90000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90001       };
90002     } catch (...) {
90003       {
90004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90005       };
90006     }
90007   }
90008 }
90009
90010
90011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90012   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90013   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
90014
90015   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90016   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
90017   {
90018     try {
90019       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
90020     } catch (std::out_of_range& e) {
90021       {
90022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90023       };
90024     } catch (std::exception& e) {
90025       {
90026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90027       };
90028     } catch (...) {
90029       {
90030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90031       };
90032     }
90033   }
90034 }
90035
90036
90037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
90038   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90039   Dali::Toolkit::StyleManager arg2 ;
90040   Dali::StyleChange::Type arg3 ;
90041   Dali::Toolkit::StyleManager *argp2 ;
90042
90043   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90044   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
90045   if (!argp2) {
90046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
90047     return ;
90048   }
90049   arg2 = *argp2;
90050   arg3 = (Dali::StyleChange::Type)jarg3;
90051   {
90052     try {
90053       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
90054     } catch (std::out_of_range& e) {
90055       {
90056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90057       };
90058     } catch (std::exception& e) {
90059       {
90060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90061       };
90062     } catch (...) {
90063       {
90064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90065       };
90066     }
90067   }
90068 }
90069
90070
90071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
90072   void * jresult ;
90073   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
90074
90075   {
90076     try {
90077       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
90078     } catch (std::out_of_range& e) {
90079       {
90080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90081       };
90082     } catch (std::exception& e) {
90083       {
90084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90085       };
90086     } catch (...) {
90087       {
90088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90089       };
90090     }
90091   }
90092   jresult = (void *)result;
90093   return jresult;
90094 }
90095
90096
90097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
90098   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90099
90100   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90101   {
90102     try {
90103       delete arg1;
90104     } catch (std::out_of_range& e) {
90105       {
90106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90107       };
90108     } catch (std::exception& e) {
90109       {
90110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90111       };
90112     } catch (...) {
90113       {
90114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90115       };
90116     }
90117   }
90118 }
90119
90120
90121 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
90122   unsigned int jresult ;
90123   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90124   bool result;
90125
90126   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90127   {
90128     try {
90129       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
90130     } catch (std::out_of_range& e) {
90131       {
90132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90133       };
90134     } catch (std::exception& e) {
90135       {
90136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90137       };
90138     } catch (...) {
90139       {
90140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90141       };
90142     }
90143   }
90144   jresult = result;
90145   return jresult;
90146 }
90147
90148
90149 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
90150   unsigned long jresult ;
90151   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90152   std::size_t result;
90153
90154   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90155   {
90156     try {
90157       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
90158     } catch (std::out_of_range& e) {
90159       {
90160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90161       };
90162     } catch (std::exception& e) {
90163       {
90164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90165       };
90166     } catch (...) {
90167       {
90168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90169       };
90170     }
90171   }
90172   jresult = (unsigned long)result;
90173   return jresult;
90174 }
90175
90176
90177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
90178   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90179   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
90180
90181   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90182   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
90183   {
90184     try {
90185       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
90186     } catch (std::out_of_range& e) {
90187       {
90188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90189       };
90190     } catch (std::exception& e) {
90191       {
90192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90193       };
90194     } catch (...) {
90195       {
90196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90197       };
90198     }
90199   }
90200 }
90201
90202
90203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
90204   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90205   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
90206
90207   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90208   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
90209   {
90210     try {
90211       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
90212     } catch (std::out_of_range& e) {
90213       {
90214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90215       };
90216     } catch (std::exception& e) {
90217       {
90218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90219       };
90220     } catch (...) {
90221       {
90222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90223       };
90224     }
90225   }
90226 }
90227
90228
90229 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
90230   unsigned int jresult ;
90231   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90232   Dali::Toolkit::Button arg2 ;
90233   Dali::Toolkit::Button *argp2 ;
90234   bool result;
90235
90236   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90237   argp2 = (Dali::Toolkit::Button *)jarg2;
90238   if (!argp2) {
90239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
90240     return 0;
90241   }
90242   arg2 = *argp2;
90243   {
90244     try {
90245       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
90246     } catch (std::out_of_range& e) {
90247       {
90248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90249       };
90250     } catch (std::exception& e) {
90251       {
90252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90253       };
90254     } catch (...) {
90255       {
90256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90257       };
90258     }
90259   }
90260   jresult = result;
90261   return jresult;
90262 }
90263
90264
90265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
90266   void * jresult ;
90267   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
90268
90269   {
90270     try {
90271       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
90272     } catch (std::out_of_range& e) {
90273       {
90274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90275       };
90276     } catch (std::exception& e) {
90277       {
90278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90279       };
90280     } catch (...) {
90281       {
90282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90283       };
90284     }
90285   }
90286   jresult = (void *)result;
90287   return jresult;
90288 }
90289
90290
90291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
90292   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90293
90294   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90295   {
90296     try {
90297       delete arg1;
90298     } catch (std::out_of_range& e) {
90299       {
90300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90301       };
90302     } catch (std::exception& e) {
90303       {
90304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90305       };
90306     } catch (...) {
90307       {
90308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90309       };
90310     }
90311   }
90312 }
90313
90314
90315 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
90316   unsigned int jresult ;
90317   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90318   bool result;
90319
90320   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90321   {
90322     try {
90323       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
90324     } catch (std::out_of_range& e) {
90325       {
90326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90327       };
90328     } catch (std::exception& e) {
90329       {
90330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90331       };
90332     } catch (...) {
90333       {
90334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90335       };
90336     }
90337   }
90338   jresult = result;
90339   return jresult;
90340 }
90341
90342
90343 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
90344   unsigned long jresult ;
90345   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90346   std::size_t result;
90347
90348   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90349   {
90350     try {
90351       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
90352     } catch (std::out_of_range& e) {
90353       {
90354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90355       };
90356     } catch (std::exception& e) {
90357       {
90358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90359       };
90360     } catch (...) {
90361       {
90362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90363       };
90364     }
90365   }
90366   jresult = (unsigned long)result;
90367   return jresult;
90368 }
90369
90370
90371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
90372   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90373   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
90374
90375   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90376   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
90377   {
90378     try {
90379       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
90380     } catch (std::out_of_range& e) {
90381       {
90382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90383       };
90384     } catch (std::exception& e) {
90385       {
90386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90387       };
90388     } catch (...) {
90389       {
90390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90391       };
90392     }
90393   }
90394 }
90395
90396
90397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
90398   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90399   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
90400
90401   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90402   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
90403   {
90404     try {
90405       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
90406     } catch (std::out_of_range& e) {
90407       {
90408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90409       };
90410     } catch (std::exception& e) {
90411       {
90412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90413       };
90414     } catch (...) {
90415       {
90416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90417       };
90418     }
90419   }
90420 }
90421
90422
90423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
90424   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90425   Dali::Toolkit::GaussianBlurView arg2 ;
90426   Dali::Toolkit::GaussianBlurView *argp2 ;
90427
90428   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90429   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
90430   if (!argp2) {
90431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
90432     return ;
90433   }
90434   arg2 = *argp2;
90435   {
90436     try {
90437       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
90438     } catch (std::out_of_range& e) {
90439       {
90440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90441       };
90442     } catch (std::exception& e) {
90443       {
90444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90445       };
90446     } catch (...) {
90447       {
90448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90449       };
90450     }
90451   }
90452 }
90453
90454
90455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
90456   void * jresult ;
90457   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
90458
90459   {
90460     try {
90461       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
90462     } catch (std::out_of_range& e) {
90463       {
90464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90465       };
90466     } catch (std::exception& e) {
90467       {
90468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90469       };
90470     } catch (...) {
90471       {
90472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90473       };
90474     }
90475   }
90476   jresult = (void *)result;
90477   return jresult;
90478 }
90479
90480
90481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
90482   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90483
90484   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90485   {
90486     try {
90487       delete arg1;
90488     } catch (std::out_of_range& e) {
90489       {
90490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90491       };
90492     } catch (std::exception& e) {
90493       {
90494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90495       };
90496     } catch (...) {
90497       {
90498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90499       };
90500     }
90501   }
90502 }
90503
90504
90505 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
90506   unsigned int jresult ;
90507   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90508   bool result;
90509
90510   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90511   {
90512     try {
90513       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);
90514     } catch (std::out_of_range& e) {
90515       {
90516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90517       };
90518     } catch (std::exception& e) {
90519       {
90520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90521       };
90522     } catch (...) {
90523       {
90524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90525       };
90526     }
90527   }
90528   jresult = result;
90529   return jresult;
90530 }
90531
90532
90533 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
90534   unsigned long jresult ;
90535   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90536   std::size_t result;
90537
90538   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90539   {
90540     try {
90541       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);
90542     } catch (std::out_of_range& e) {
90543       {
90544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90545       };
90546     } catch (std::exception& e) {
90547       {
90548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90549       };
90550     } catch (...) {
90551       {
90552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90553       };
90554     }
90555   }
90556   jresult = (unsigned long)result;
90557   return jresult;
90558 }
90559
90560
90561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
90562   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90563   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
90564
90565   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90566   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
90567   {
90568     try {
90569       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
90570     } catch (std::out_of_range& e) {
90571       {
90572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90573       };
90574     } catch (std::exception& e) {
90575       {
90576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90577       };
90578     } catch (...) {
90579       {
90580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90581       };
90582     }
90583   }
90584 }
90585
90586
90587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
90588   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90589   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
90590
90591   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90592   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
90593   {
90594     try {
90595       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
90596     } catch (std::out_of_range& e) {
90597       {
90598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90599       };
90600     } catch (std::exception& e) {
90601       {
90602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90603       };
90604     } catch (...) {
90605       {
90606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90607       };
90608     }
90609   }
90610 }
90611
90612
90613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
90614   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90615   Dali::Toolkit::PageTurnView arg2 ;
90616   unsigned int arg3 ;
90617   bool arg4 ;
90618   Dali::Toolkit::PageTurnView *argp2 ;
90619
90620   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90621   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
90622   if (!argp2) {
90623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
90624     return ;
90625   }
90626   arg2 = *argp2;
90627   arg3 = (unsigned int)jarg3;
90628   arg4 = jarg4 ? true : false;
90629   {
90630     try {
90631       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
90632     } catch (std::out_of_range& e) {
90633       {
90634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90635       };
90636     } catch (std::exception& e) {
90637       {
90638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90639       };
90640     } catch (...) {
90641       {
90642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90643       };
90644     }
90645   }
90646 }
90647
90648
90649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
90650   void * jresult ;
90651   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
90652
90653   {
90654     try {
90655       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
90656     } catch (std::out_of_range& e) {
90657       {
90658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90659       };
90660     } catch (std::exception& e) {
90661       {
90662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90663       };
90664     } catch (...) {
90665       {
90666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90667       };
90668     }
90669   }
90670   jresult = (void *)result;
90671   return jresult;
90672 }
90673
90674
90675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
90676   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90677
90678   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90679   {
90680     try {
90681       delete arg1;
90682     } catch (std::out_of_range& e) {
90683       {
90684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90685       };
90686     } catch (std::exception& e) {
90687       {
90688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90689       };
90690     } catch (...) {
90691       {
90692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90693       };
90694     }
90695   }
90696 }
90697
90698
90699 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
90700   unsigned int jresult ;
90701   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90702   bool result;
90703
90704   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90705   {
90706     try {
90707       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
90708     } catch (std::out_of_range& e) {
90709       {
90710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90711       };
90712     } catch (std::exception& e) {
90713       {
90714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90715       };
90716     } catch (...) {
90717       {
90718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90719       };
90720     }
90721   }
90722   jresult = result;
90723   return jresult;
90724 }
90725
90726
90727 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
90728   unsigned long jresult ;
90729   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90730   std::size_t result;
90731
90732   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90733   {
90734     try {
90735       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
90736     } catch (std::out_of_range& e) {
90737       {
90738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90739       };
90740     } catch (std::exception& e) {
90741       {
90742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90743       };
90744     } catch (...) {
90745       {
90746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90747       };
90748     }
90749   }
90750   jresult = (unsigned long)result;
90751   return jresult;
90752 }
90753
90754
90755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
90756   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90757   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
90758
90759   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90760   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
90761   {
90762     try {
90763       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
90764     } catch (std::out_of_range& e) {
90765       {
90766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90767       };
90768     } catch (std::exception& e) {
90769       {
90770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90771       };
90772     } catch (...) {
90773       {
90774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90775       };
90776     }
90777   }
90778 }
90779
90780
90781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
90782   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90783   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
90784
90785   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90786   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
90787   {
90788     try {
90789       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
90790     } catch (std::out_of_range& e) {
90791       {
90792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90793       };
90794     } catch (std::exception& e) {
90795       {
90796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90797       };
90798     } catch (...) {
90799       {
90800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90801       };
90802     }
90803   }
90804 }
90805
90806
90807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
90808   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90809   Dali::Toolkit::PageTurnView arg2 ;
90810   Dali::Toolkit::PageTurnView *argp2 ;
90811
90812   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90813   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
90814   if (!argp2) {
90815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
90816     return ;
90817   }
90818   arg2 = *argp2;
90819   {
90820     try {
90821       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
90822     } catch (std::out_of_range& e) {
90823       {
90824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90825       };
90826     } catch (std::exception& e) {
90827       {
90828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90829       };
90830     } catch (...) {
90831       {
90832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90833       };
90834     }
90835   }
90836 }
90837
90838
90839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
90840   void * jresult ;
90841   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
90842
90843   {
90844     try {
90845       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
90846     } catch (std::out_of_range& e) {
90847       {
90848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90849       };
90850     } catch (std::exception& e) {
90851       {
90852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90853       };
90854     } catch (...) {
90855       {
90856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90857       };
90858     }
90859   }
90860   jresult = (void *)result;
90861   return jresult;
90862 }
90863
90864
90865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
90866   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90867
90868   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90869   {
90870     try {
90871       delete arg1;
90872     } catch (std::out_of_range& e) {
90873       {
90874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90875       };
90876     } catch (std::exception& e) {
90877       {
90878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90879       };
90880     } catch (...) {
90881       {
90882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90883       };
90884     }
90885   }
90886 }
90887
90888
90889 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
90890   unsigned int jresult ;
90891   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
90892   bool result;
90893
90894   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
90895   {
90896     try {
90897       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);
90898     } catch (std::out_of_range& e) {
90899       {
90900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90901       };
90902     } catch (std::exception& e) {
90903       {
90904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90905       };
90906     } catch (...) {
90907       {
90908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90909       };
90910     }
90911   }
90912   jresult = result;
90913   return jresult;
90914 }
90915
90916
90917 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
90918   unsigned long jresult ;
90919   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
90920   std::size_t result;
90921
90922   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
90923   {
90924     try {
90925       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);
90926     } catch (std::out_of_range& e) {
90927       {
90928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90929       };
90930     } catch (std::exception& e) {
90931       {
90932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90933       };
90934     } catch (...) {
90935       {
90936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90937       };
90938     }
90939   }
90940   jresult = (unsigned long)result;
90941   return jresult;
90942 }
90943
90944
90945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
90946   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
90947   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
90948
90949   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
90950   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
90951   {
90952     try {
90953       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
90954     } catch (std::out_of_range& e) {
90955       {
90956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90957       };
90958     } catch (std::exception& e) {
90959       {
90960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90961       };
90962     } catch (...) {
90963       {
90964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90965       };
90966     }
90967   }
90968 }
90969
90970
90971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90972   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
90973   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
90974
90975   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
90976   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
90977   {
90978     try {
90979       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
90980     } catch (std::out_of_range& e) {
90981       {
90982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90983       };
90984     } catch (std::exception& e) {
90985       {
90986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90987       };
90988     } catch (...) {
90989       {
90990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90991       };
90992     }
90993   }
90994 }
90995
90996
90997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
90998   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
90999   Dali::Toolkit::ProgressBar arg2 ;
91000   float arg3 ;
91001   float arg4 ;
91002   Dali::Toolkit::ProgressBar *argp2 ;
91003
91004   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91005   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
91006   if (!argp2) {
91007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
91008     return ;
91009   }
91010   arg2 = *argp2;
91011   arg3 = (float)jarg3;
91012   arg4 = (float)jarg4;
91013   {
91014     try {
91015       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
91016     } catch (std::out_of_range& e) {
91017       {
91018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91019       };
91020     } catch (std::exception& e) {
91021       {
91022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91023       };
91024     } catch (...) {
91025       {
91026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91027       };
91028     }
91029   }
91030 }
91031
91032
91033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
91034   void * jresult ;
91035   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
91036
91037   {
91038     try {
91039       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
91040     } catch (std::out_of_range& e) {
91041       {
91042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91043       };
91044     } catch (std::exception& e) {
91045       {
91046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91047       };
91048     } catch (...) {
91049       {
91050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91051       };
91052     }
91053   }
91054   jresult = (void *)result;
91055   return jresult;
91056 }
91057
91058
91059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
91060   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91061
91062   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91063   {
91064     try {
91065       delete arg1;
91066     } catch (std::out_of_range& e) {
91067       {
91068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91069       };
91070     } catch (std::exception& e) {
91071       {
91072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91073       };
91074     } catch (...) {
91075       {
91076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91077       };
91078     }
91079   }
91080 }
91081
91082
91083 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
91084   unsigned int jresult ;
91085   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91086   bool result;
91087
91088   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91089   {
91090     try {
91091       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);
91092     } catch (std::out_of_range& e) {
91093       {
91094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91095       };
91096     } catch (std::exception& e) {
91097       {
91098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91099       };
91100     } catch (...) {
91101       {
91102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91103       };
91104     }
91105   }
91106   jresult = result;
91107   return jresult;
91108 }
91109
91110
91111 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
91112   unsigned long jresult ;
91113   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91114   std::size_t result;
91115
91116   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91117   {
91118     try {
91119       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);
91120     } catch (std::out_of_range& e) {
91121       {
91122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91123       };
91124     } catch (std::exception& e) {
91125       {
91126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91127       };
91128     } catch (...) {
91129       {
91130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91131       };
91132     }
91133   }
91134   jresult = (unsigned long)result;
91135   return jresult;
91136 }
91137
91138
91139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
91140   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91141   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
91142
91143   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91144   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
91145   {
91146     try {
91147       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
91148     } catch (std::out_of_range& e) {
91149       {
91150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91151       };
91152     } catch (std::exception& e) {
91153       {
91154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91155       };
91156     } catch (...) {
91157       {
91158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91159       };
91160     }
91161   }
91162 }
91163
91164
91165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
91166   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91167   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
91168
91169   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91170   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
91171   {
91172     try {
91173       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
91174     } catch (std::out_of_range& e) {
91175       {
91176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91177       };
91178     } catch (std::exception& e) {
91179       {
91180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91181       };
91182     } catch (...) {
91183       {
91184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91185       };
91186     }
91187   }
91188 }
91189
91190
91191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
91192   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91193   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
91194
91195   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91196   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
91197   if (!arg2) {
91198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
91199     return ;
91200   }
91201   {
91202     try {
91203       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
91204     } catch (std::out_of_range& e) {
91205       {
91206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91207       };
91208     } catch (std::exception& e) {
91209       {
91210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91211       };
91212     } catch (...) {
91213       {
91214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91215       };
91216     }
91217   }
91218 }
91219
91220
91221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
91222   void * jresult ;
91223   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
91224
91225   {
91226     try {
91227       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
91228     } catch (std::out_of_range& e) {
91229       {
91230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91231       };
91232     } catch (std::exception& e) {
91233       {
91234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91235       };
91236     } catch (...) {
91237       {
91238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91239       };
91240     }
91241   }
91242   jresult = (void *)result;
91243   return jresult;
91244 }
91245
91246
91247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
91248   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91249
91250   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91251   {
91252     try {
91253       delete arg1;
91254     } catch (std::out_of_range& e) {
91255       {
91256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91257       };
91258     } catch (std::exception& e) {
91259       {
91260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91261       };
91262     } catch (...) {
91263       {
91264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91265       };
91266     }
91267   }
91268 }
91269
91270
91271 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
91272   unsigned int jresult ;
91273   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91274   bool result;
91275
91276   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91277   {
91278     try {
91279       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
91280     } catch (std::out_of_range& e) {
91281       {
91282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91283       };
91284     } catch (std::exception& e) {
91285       {
91286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91287       };
91288     } catch (...) {
91289       {
91290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91291       };
91292     }
91293   }
91294   jresult = result;
91295   return jresult;
91296 }
91297
91298
91299 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
91300   unsigned long jresult ;
91301   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91302   std::size_t result;
91303
91304   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91305   {
91306     try {
91307       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
91308     } catch (std::out_of_range& e) {
91309       {
91310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91311       };
91312     } catch (std::exception& e) {
91313       {
91314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91315       };
91316     } catch (...) {
91317       {
91318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91319       };
91320     }
91321   }
91322   jresult = (unsigned long)result;
91323   return jresult;
91324 }
91325
91326
91327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
91328   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91329   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
91330
91331   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91332   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
91333   {
91334     try {
91335       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
91336     } catch (std::out_of_range& e) {
91337       {
91338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91339       };
91340     } catch (std::exception& e) {
91341       {
91342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91343       };
91344     } catch (...) {
91345       {
91346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91347       };
91348     }
91349   }
91350 }
91351
91352
91353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
91354   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91355   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
91356
91357   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91358   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
91359   {
91360     try {
91361       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
91362     } catch (std::out_of_range& e) {
91363       {
91364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91365       };
91366     } catch (std::exception& e) {
91367       {
91368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91369       };
91370     } catch (...) {
91371       {
91372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91373       };
91374     }
91375   }
91376 }
91377
91378
91379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
91380   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91381   Dali::Vector2 *arg2 = 0 ;
91382
91383   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91384   arg2 = (Dali::Vector2 *)jarg2;
91385   if (!arg2) {
91386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
91387     return ;
91388   }
91389   {
91390     try {
91391       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
91392     } catch (std::out_of_range& e) {
91393       {
91394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91395       };
91396     } catch (std::exception& e) {
91397       {
91398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91399       };
91400     } catch (...) {
91401       {
91402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91403       };
91404     }
91405   }
91406 }
91407
91408
91409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
91410   void * jresult ;
91411   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
91412
91413   {
91414     try {
91415       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
91416     } catch (std::out_of_range& e) {
91417       {
91418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91419       };
91420     } catch (std::exception& e) {
91421       {
91422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91423       };
91424     } catch (...) {
91425       {
91426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91427       };
91428     }
91429   }
91430   jresult = (void *)result;
91431   return jresult;
91432 }
91433
91434
91435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
91436   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91437
91438   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91439   {
91440     try {
91441       delete arg1;
91442     } catch (std::out_of_range& e) {
91443       {
91444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91445       };
91446     } catch (std::exception& e) {
91447       {
91448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91449       };
91450     } catch (...) {
91451       {
91452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91453       };
91454     }
91455   }
91456 }
91457
91458
91459 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextEditorSignal_Empty(void * jarg1) {
91460   unsigned int jresult ;
91461   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91462   bool result;
91463
91464   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91465   {
91466     try {
91467       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
91468     } catch (std::out_of_range& e) {
91469       {
91470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91471       };
91472     } catch (std::exception& e) {
91473       {
91474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91475       };
91476     } catch (...) {
91477       {
91478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91479       };
91480     }
91481   }
91482   jresult = result;
91483   return jresult;
91484 }
91485
91486
91487 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextEditorSignal_GetConnectionCount(void * jarg1) {
91488   unsigned long jresult ;
91489   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91490   std::size_t result;
91491
91492   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91493   {
91494     try {
91495       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
91496     } catch (std::out_of_range& e) {
91497       {
91498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91499       };
91500     } catch (std::exception& e) {
91501       {
91502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91503       };
91504     } catch (...) {
91505       {
91506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91507       };
91508     }
91509   }
91510   jresult = (unsigned long)result;
91511   return jresult;
91512 }
91513
91514
91515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Connect(void * jarg1, void * jarg2) {
91516   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91517   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
91518
91519   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91520   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
91521   {
91522     try {
91523       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Connect(arg1,arg2);
91524     } catch (std::out_of_range& e) {
91525       {
91526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91527       };
91528     } catch (std::exception& e) {
91529       {
91530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91531       };
91532     } catch (...) {
91533       {
91534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91535       };
91536     }
91537   }
91538 }
91539
91540
91541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Disconnect(void * jarg1, void * jarg2) {
91542   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91543   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
91544
91545   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91546   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
91547   {
91548     try {
91549       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Disconnect(arg1,arg2);
91550     } catch (std::out_of_range& e) {
91551       {
91552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91553       };
91554     } catch (std::exception& e) {
91555       {
91556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91557       };
91558     } catch (...) {
91559       {
91560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91561       };
91562     }
91563   }
91564 }
91565
91566
91567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Emit(void * jarg1, void * jarg2) {
91568   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91569   Dali::Toolkit::TextEditor arg2 ;
91570   Dali::Toolkit::TextEditor *argp2 ;
91571
91572   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91573   argp2 = (Dali::Toolkit::TextEditor *)jarg2;
91574   if (!argp2) {
91575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextEditor", 0);
91576     return ;
91577   }
91578   arg2 = *argp2;
91579   {
91580     try {
91581       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(arg1,arg2);
91582     } catch (std::out_of_range& e) {
91583       {
91584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91585       };
91586     } catch (std::exception& e) {
91587       {
91588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91589       };
91590     } catch (...) {
91591       {
91592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91593       };
91594     }
91595   }
91596 }
91597
91598
91599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditorSignal() {
91600   void * jresult ;
91601   Dali::Signal< void (Dali::Toolkit::TextEditor) > *result = 0 ;
91602
91603   {
91604     try {
91605       result = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)new Dali::Signal< void (Dali::Toolkit::TextEditor) >();
91606     } catch (std::out_of_range& e) {
91607       {
91608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91609       };
91610     } catch (std::exception& e) {
91611       {
91612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91613       };
91614     } catch (...) {
91615       {
91616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91617       };
91618     }
91619   }
91620   jresult = (void *)result;
91621   return jresult;
91622 }
91623
91624
91625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditorSignal(void * jarg1) {
91626   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91627
91628   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91629   {
91630     try {
91631       delete arg1;
91632     } catch (std::out_of_range& e) {
91633       {
91634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91635       };
91636     } catch (std::exception& e) {
91637       {
91638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91639       };
91640     } catch (...) {
91641       {
91642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91643       };
91644     }
91645   }
91646 }
91647
91648
91649 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextFieldSignal_Empty(void * jarg1) {
91650   unsigned int jresult ;
91651   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91652   bool result;
91653
91654   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91655   {
91656     try {
91657       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
91658     } catch (std::out_of_range& e) {
91659       {
91660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91661       };
91662     } catch (std::exception& e) {
91663       {
91664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91665       };
91666     } catch (...) {
91667       {
91668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91669       };
91670     }
91671   }
91672   jresult = result;
91673   return jresult;
91674 }
91675
91676
91677 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextFieldSignal_GetConnectionCount(void * jarg1) {
91678   unsigned long jresult ;
91679   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91680   std::size_t result;
91681
91682   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91683   {
91684     try {
91685       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
91686     } catch (std::out_of_range& e) {
91687       {
91688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91689       };
91690     } catch (std::exception& e) {
91691       {
91692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91693       };
91694     } catch (...) {
91695       {
91696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91697       };
91698     }
91699   }
91700   jresult = (unsigned long)result;
91701   return jresult;
91702 }
91703
91704
91705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Connect(void * jarg1, void * jarg2) {
91706   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91707   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
91708
91709   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91710   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
91711   {
91712     try {
91713       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Connect(arg1,arg2);
91714     } catch (std::out_of_range& e) {
91715       {
91716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91717       };
91718     } catch (std::exception& e) {
91719       {
91720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91721       };
91722     } catch (...) {
91723       {
91724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91725       };
91726     }
91727   }
91728 }
91729
91730
91731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Disconnect(void * jarg1, void * jarg2) {
91732   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91733   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
91734
91735   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91736   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
91737   {
91738     try {
91739       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Disconnect(arg1,arg2);
91740     } catch (std::out_of_range& e) {
91741       {
91742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91743       };
91744     } catch (std::exception& e) {
91745       {
91746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91747       };
91748     } catch (...) {
91749       {
91750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91751       };
91752     }
91753   }
91754 }
91755
91756
91757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Emit(void * jarg1, void * jarg2) {
91758   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91759   Dali::Toolkit::TextField arg2 ;
91760   Dali::Toolkit::TextField *argp2 ;
91761
91762   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91763   argp2 = (Dali::Toolkit::TextField *)jarg2;
91764   if (!argp2) {
91765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextField", 0);
91766     return ;
91767   }
91768   arg2 = *argp2;
91769   {
91770     try {
91771       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(arg1,arg2);
91772     } catch (std::out_of_range& e) {
91773       {
91774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91775       };
91776     } catch (std::exception& e) {
91777       {
91778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91779       };
91780     } catch (...) {
91781       {
91782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91783       };
91784     }
91785   }
91786 }
91787
91788
91789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextFieldSignal() {
91790   void * jresult ;
91791   Dali::Signal< void (Dali::Toolkit::TextField) > *result = 0 ;
91792
91793   {
91794     try {
91795       result = (Dali::Signal< void (Dali::Toolkit::TextField) > *)new Dali::Signal< void (Dali::Toolkit::TextField) >();
91796     } catch (std::out_of_range& e) {
91797       {
91798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91799       };
91800     } catch (std::exception& e) {
91801       {
91802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91803       };
91804     } catch (...) {
91805       {
91806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91807       };
91808     }
91809   }
91810   jresult = (void *)result;
91811   return jresult;
91812 }
91813
91814
91815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextFieldSignal(void * jarg1) {
91816   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91817
91818   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91819   {
91820     try {
91821       delete arg1;
91822     } catch (std::out_of_range& e) {
91823       {
91824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91825       };
91826     } catch (std::exception& e) {
91827       {
91828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91829       };
91830     } catch (...) {
91831       {
91832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91833       };
91834     }
91835   }
91836 }
91837
91838
91839 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
91840   unsigned int jresult ;
91841   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91842   bool result;
91843
91844   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91845   {
91846     try {
91847       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);
91848     } catch (std::out_of_range& e) {
91849       {
91850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91851       };
91852     } catch (std::exception& e) {
91853       {
91854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91855       };
91856     } catch (...) {
91857       {
91858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91859       };
91860     }
91861   }
91862   jresult = result;
91863   return jresult;
91864 }
91865
91866
91867 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
91868   unsigned long jresult ;
91869   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91870   std::size_t result;
91871
91872   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91873   {
91874     try {
91875       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);
91876     } catch (std::out_of_range& e) {
91877       {
91878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91879       };
91880     } catch (std::exception& e) {
91881       {
91882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91883       };
91884     } catch (...) {
91885       {
91886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91887       };
91888     }
91889   }
91890   jresult = (unsigned long)result;
91891   return jresult;
91892 }
91893
91894
91895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
91896   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91897   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
91898
91899   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91900   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
91901   {
91902     try {
91903       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
91904     } catch (std::out_of_range& e) {
91905       {
91906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91907       };
91908     } catch (std::exception& e) {
91909       {
91910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91911       };
91912     } catch (...) {
91913       {
91914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91915       };
91916     }
91917   }
91918 }
91919
91920
91921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
91922   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91923   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
91924
91925   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91926   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
91927   {
91928     try {
91929       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
91930     } catch (std::out_of_range& e) {
91931       {
91932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91933       };
91934     } catch (std::exception& e) {
91935       {
91936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91937       };
91938     } catch (...) {
91939       {
91940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91941       };
91942     }
91943   }
91944 }
91945
91946
91947 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
91948   unsigned int jresult ;
91949   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91950   Dali::Toolkit::Control arg2 ;
91951   Dali::KeyEvent *arg3 = 0 ;
91952   Dali::Toolkit::Control *argp2 ;
91953   bool result;
91954
91955   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91956   argp2 = (Dali::Toolkit::Control *)jarg2;
91957   if (!argp2) {
91958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
91959     return 0;
91960   }
91961   arg2 = *argp2;
91962   arg3 = (Dali::KeyEvent *)jarg3;
91963   if (!arg3) {
91964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
91965     return 0;
91966   }
91967   {
91968     try {
91969       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);
91970     } catch (std::out_of_range& e) {
91971       {
91972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91973       };
91974     } catch (std::exception& e) {
91975       {
91976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91977       };
91978     } catch (...) {
91979       {
91980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91981       };
91982     }
91983   }
91984   jresult = result;
91985   return jresult;
91986 }
91987
91988
91989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
91990   void * jresult ;
91991   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
91992
91993   {
91994     try {
91995       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
91996     } catch (std::out_of_range& e) {
91997       {
91998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91999       };
92000     } catch (std::exception& e) {
92001       {
92002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92003       };
92004     } catch (...) {
92005       {
92006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92007       };
92008     }
92009   }
92010   jresult = (void *)result;
92011   return jresult;
92012 }
92013
92014
92015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
92016   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92017
92018   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92019   {
92020     try {
92021       delete arg1;
92022     } catch (std::out_of_range& e) {
92023       {
92024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92025       };
92026     } catch (std::exception& e) {
92027       {
92028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92029       };
92030     } catch (...) {
92031       {
92032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92033       };
92034     }
92035   }
92036 }
92037
92038
92039 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
92040   unsigned int jresult ;
92041   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92042   bool result;
92043
92044   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92045   {
92046     try {
92047       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
92048     } catch (std::out_of_range& e) {
92049       {
92050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92051       };
92052     } catch (std::exception& e) {
92053       {
92054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92055       };
92056     } catch (...) {
92057       {
92058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92059       };
92060     }
92061   }
92062   jresult = result;
92063   return jresult;
92064 }
92065
92066
92067 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
92068   unsigned long jresult ;
92069   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92070   std::size_t result;
92071
92072   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92073   {
92074     try {
92075       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
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 = (unsigned long)result;
92091   return jresult;
92092 }
92093
92094
92095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
92096   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92097   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
92098
92099   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92100   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
92101   {
92102     try {
92103       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
92104     } catch (std::out_of_range& e) {
92105       {
92106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92107       };
92108     } catch (std::exception& e) {
92109       {
92110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92111       };
92112     } catch (...) {
92113       {
92114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92115       };
92116     }
92117   }
92118 }
92119
92120
92121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
92122   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92123   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
92124
92125   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92126   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
92127   {
92128     try {
92129       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
92130     } catch (std::out_of_range& e) {
92131       {
92132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92133       };
92134     } catch (std::exception& e) {
92135       {
92136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92137       };
92138     } catch (...) {
92139       {
92140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92141       };
92142     }
92143   }
92144 }
92145
92146
92147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
92148   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92149   Dali::Toolkit::Control arg2 ;
92150   Dali::Toolkit::Control *argp2 ;
92151
92152   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92153   argp2 = (Dali::Toolkit::Control *)jarg2;
92154   if (!argp2) {
92155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
92156     return ;
92157   }
92158   arg2 = *argp2;
92159   {
92160     try {
92161       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
92162     } catch (std::out_of_range& e) {
92163       {
92164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92165       };
92166     } catch (std::exception& e) {
92167       {
92168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92169       };
92170     } catch (...) {
92171       {
92172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92173       };
92174     }
92175   }
92176 }
92177
92178
92179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
92180   void * jresult ;
92181   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
92182
92183   {
92184     try {
92185       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
92186     } catch (std::out_of_range& e) {
92187       {
92188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92189       };
92190     } catch (std::exception& e) {
92191       {
92192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92193       };
92194     } catch (...) {
92195       {
92196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92197       };
92198     }
92199   }
92200   jresult = (void *)result;
92201   return jresult;
92202 }
92203
92204
92205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
92206   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92207
92208   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92209   {
92210     try {
92211       delete arg1;
92212     } catch (std::out_of_range& e) {
92213       {
92214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92215       };
92216     } catch (std::exception& e) {
92217       {
92218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92219       };
92220     } catch (...) {
92221       {
92222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92223       };
92224     }
92225   }
92226 }
92227
92228
92229 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
92230   unsigned int jresult ;
92231   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92232   bool result;
92233
92234   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92235   {
92236     try {
92237       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
92238     } catch (std::out_of_range& e) {
92239       {
92240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92241       };
92242     } catch (std::exception& e) {
92243       {
92244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92245       };
92246     } catch (...) {
92247       {
92248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92249       };
92250     }
92251   }
92252   jresult = result;
92253   return jresult;
92254 }
92255
92256
92257 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
92258   unsigned long jresult ;
92259   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92260   std::size_t result;
92261
92262   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92263   {
92264     try {
92265       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
92266     } catch (std::out_of_range& e) {
92267       {
92268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92269       };
92270     } catch (std::exception& e) {
92271       {
92272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92273       };
92274     } catch (...) {
92275       {
92276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92277       };
92278     }
92279   }
92280   jresult = (unsigned long)result;
92281   return jresult;
92282 }
92283
92284
92285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
92286   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92287   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
92288
92289   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92290   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
92291   {
92292     try {
92293       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
92294     } catch (std::out_of_range& e) {
92295       {
92296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92297       };
92298     } catch (std::exception& e) {
92299       {
92300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92301       };
92302     } catch (...) {
92303       {
92304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92305       };
92306     }
92307   }
92308 }
92309
92310
92311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
92312   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92313   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
92314
92315   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92316   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
92317   {
92318     try {
92319       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
92320     } catch (std::out_of_range& e) {
92321       {
92322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92323       };
92324     } catch (std::exception& e) {
92325       {
92326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92327       };
92328     } catch (...) {
92329       {
92330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92331       };
92332     }
92333   }
92334 }
92335
92336
92337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
92338   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92339   Dali::Toolkit::VideoView *arg2 = 0 ;
92340
92341   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92342   arg2 = (Dali::Toolkit::VideoView *)jarg2;
92343   if (!arg2) {
92344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
92345     return ;
92346   }
92347   {
92348     try {
92349       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
92350     } catch (std::out_of_range& e) {
92351       {
92352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92353       };
92354     } catch (std::exception& e) {
92355       {
92356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92357       };
92358     } catch (...) {
92359       {
92360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92361       };
92362     }
92363   }
92364 }
92365
92366
92367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
92368   void * jresult ;
92369   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
92370
92371   {
92372     try {
92373       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
92374     } catch (std::out_of_range& e) {
92375       {
92376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92377       };
92378     } catch (std::exception& e) {
92379       {
92380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92381       };
92382     } catch (...) {
92383       {
92384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92385       };
92386     }
92387   }
92388   jresult = (void *)result;
92389   return jresult;
92390 }
92391
92392
92393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
92394   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92395
92396   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92397   {
92398     try {
92399       delete arg1;
92400     } catch (std::out_of_range& e) {
92401       {
92402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92403       };
92404     } catch (std::exception& e) {
92405       {
92406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92407       };
92408     } catch (...) {
92409       {
92410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92411       };
92412     }
92413   }
92414 }
92415
92416
92417 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
92418   unsigned int jresult ;
92419   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92420   bool result;
92421
92422   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92423   {
92424     try {
92425       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
92426     } catch (std::out_of_range& e) {
92427       {
92428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92429       };
92430     } catch (std::exception& e) {
92431       {
92432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92433       };
92434     } catch (...) {
92435       {
92436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92437       };
92438     }
92439   }
92440   jresult = result;
92441   return jresult;
92442 }
92443
92444
92445 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
92446   unsigned long jresult ;
92447   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92448   std::size_t result;
92449
92450   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92451   {
92452     try {
92453       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
92454     } catch (std::out_of_range& e) {
92455       {
92456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92457       };
92458     } catch (std::exception& e) {
92459       {
92460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92461       };
92462     } catch (...) {
92463       {
92464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92465       };
92466     }
92467   }
92468   jresult = (unsigned long)result;
92469   return jresult;
92470 }
92471
92472
92473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
92474   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92475   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
92476
92477   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92478   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
92479   {
92480     try {
92481       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
92482     } catch (std::out_of_range& e) {
92483       {
92484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92485       };
92486     } catch (std::exception& e) {
92487       {
92488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92489       };
92490     } catch (...) {
92491       {
92492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92493       };
92494     }
92495   }
92496 }
92497
92498
92499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
92500   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92501   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
92502
92503   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92504   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
92505   {
92506     try {
92507       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
92508     } catch (std::out_of_range& e) {
92509       {
92510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92511       };
92512     } catch (std::exception& e) {
92513       {
92514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92515       };
92516     } catch (...) {
92517       {
92518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92519       };
92520     }
92521   }
92522 }
92523
92524
92525 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
92526   unsigned int jresult ;
92527   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92528   Dali::Toolkit::Slider arg2 ;
92529   float arg3 ;
92530   Dali::Toolkit::Slider *argp2 ;
92531   bool result;
92532
92533   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92534   argp2 = (Dali::Toolkit::Slider *)jarg2;
92535   if (!argp2) {
92536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
92537     return 0;
92538   }
92539   arg2 = *argp2;
92540   arg3 = (float)jarg3;
92541   {
92542     try {
92543       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
92544     } catch (std::out_of_range& e) {
92545       {
92546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92547       };
92548     } catch (std::exception& e) {
92549       {
92550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92551       };
92552     } catch (...) {
92553       {
92554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92555       };
92556     }
92557   }
92558   jresult = result;
92559   return jresult;
92560 }
92561
92562
92563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
92564   void * jresult ;
92565   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
92566
92567   {
92568     try {
92569       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
92570     } catch (std::out_of_range& e) {
92571       {
92572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92573       };
92574     } catch (std::exception& e) {
92575       {
92576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92577       };
92578     } catch (...) {
92579       {
92580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92581       };
92582     }
92583   }
92584   jresult = (void *)result;
92585   return jresult;
92586 }
92587
92588
92589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
92590   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92591
92592   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92593   {
92594     try {
92595       delete arg1;
92596     } catch (std::out_of_range& e) {
92597       {
92598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92599       };
92600     } catch (std::exception& e) {
92601       {
92602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92603       };
92604     } catch (...) {
92605       {
92606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92607       };
92608     }
92609   }
92610 }
92611
92612
92613 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
92614   unsigned int jresult ;
92615   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92616   bool result;
92617
92618   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92619   {
92620     try {
92621       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
92622     } catch (std::out_of_range& e) {
92623       {
92624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92625       };
92626     } catch (std::exception& e) {
92627       {
92628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92629       };
92630     } catch (...) {
92631       {
92632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92633       };
92634     }
92635   }
92636   jresult = result;
92637   return jresult;
92638 }
92639
92640
92641 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
92642   unsigned long jresult ;
92643   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92644   std::size_t result;
92645
92646   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92647   {
92648     try {
92649       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
92650     } catch (std::out_of_range& e) {
92651       {
92652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92653       };
92654     } catch (std::exception& e) {
92655       {
92656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92657       };
92658     } catch (...) {
92659       {
92660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92661       };
92662     }
92663   }
92664   jresult = (unsigned long)result;
92665   return jresult;
92666 }
92667
92668
92669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
92670   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92671   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
92672
92673   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92674   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
92675   {
92676     try {
92677       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
92678     } catch (std::out_of_range& e) {
92679       {
92680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92681       };
92682     } catch (std::exception& e) {
92683       {
92684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92685       };
92686     } catch (...) {
92687       {
92688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92689       };
92690     }
92691   }
92692 }
92693
92694
92695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
92696   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92697   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
92698
92699   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92700   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
92701   {
92702     try {
92703       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
92704     } catch (std::out_of_range& e) {
92705       {
92706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92707       };
92708     } catch (std::exception& e) {
92709       {
92710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92711       };
92712     } catch (...) {
92713       {
92714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92715       };
92716     }
92717   }
92718 }
92719
92720
92721 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
92722   unsigned int jresult ;
92723   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92724   Dali::Toolkit::Slider arg2 ;
92725   int arg3 ;
92726   Dali::Toolkit::Slider *argp2 ;
92727   bool result;
92728
92729   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92730   argp2 = (Dali::Toolkit::Slider *)jarg2;
92731   if (!argp2) {
92732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
92733     return 0;
92734   }
92735   arg2 = *argp2;
92736   arg3 = (int)jarg3;
92737   {
92738     try {
92739       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
92740     } catch (std::out_of_range& e) {
92741       {
92742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92743       };
92744     } catch (std::exception& e) {
92745       {
92746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92747       };
92748     } catch (...) {
92749       {
92750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92751       };
92752     }
92753   }
92754   jresult = result;
92755   return jresult;
92756 }
92757
92758
92759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
92760   void * jresult ;
92761   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
92762
92763   {
92764     try {
92765       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
92766     } catch (std::out_of_range& e) {
92767       {
92768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92769       };
92770     } catch (std::exception& e) {
92771       {
92772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92773       };
92774     } catch (...) {
92775       {
92776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92777       };
92778     }
92779   }
92780   jresult = (void *)result;
92781   return jresult;
92782 }
92783
92784
92785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
92786   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92787
92788   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92789   {
92790     try {
92791       delete arg1;
92792     } catch (std::out_of_range& e) {
92793       {
92794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92795       };
92796     } catch (std::exception& e) {
92797       {
92798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92799       };
92800     } catch (...) {
92801       {
92802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92803       };
92804     }
92805   }
92806 }
92807
92808
92809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
92810   void * jresult ;
92811   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92812
92813   {
92814     try {
92815       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
92816     } catch (std::out_of_range& e) {
92817       {
92818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92819       };
92820     } catch (std::exception& e) {
92821       {
92822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92823       };
92824     } catch (...) {
92825       {
92826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92827       };
92828     }
92829   }
92830   jresult = (void *)result;
92831   return jresult;
92832 }
92833
92834
92835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
92836   void * jresult ;
92837   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
92838   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92839
92840   arg1 = (Dali::Toolkit::Ruler *)jarg1;
92841   {
92842     try {
92843       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
92844     } catch (std::out_of_range& e) {
92845       {
92846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92847       };
92848     } catch (std::exception& e) {
92849       {
92850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92851       };
92852     } catch (...) {
92853       {
92854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92855       };
92856     }
92857   }
92858   jresult = (void *)result;
92859   return jresult;
92860 }
92861
92862
92863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
92864   void * jresult ;
92865   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
92866   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92867
92868   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92869   if (!arg1) {
92870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
92871     return 0;
92872   }
92873   {
92874     try {
92875       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
92876     } catch (std::out_of_range& e) {
92877       {
92878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92879       };
92880     } catch (std::exception& e) {
92881       {
92882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92883       };
92884     } catch (...) {
92885       {
92886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92887       };
92888     }
92889   }
92890   jresult = (void *)result;
92891   return jresult;
92892 }
92893
92894
92895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
92896   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92897
92898   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92899   {
92900     try {
92901       delete arg1;
92902     } catch (std::out_of_range& e) {
92903       {
92904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92905       };
92906     } catch (std::exception& e) {
92907       {
92908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92909       };
92910     } catch (...) {
92911       {
92912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92913       };
92914     }
92915   }
92916 }
92917
92918
92919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
92920   void * jresult ;
92921   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92922   Dali::Toolkit::Ruler *result = 0 ;
92923
92924   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92925   {
92926     try {
92927       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
92928     } catch (std::out_of_range& e) {
92929       {
92930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92931       };
92932     } catch (std::exception& e) {
92933       {
92934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92935       };
92936     } catch (...) {
92937       {
92938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92939       };
92940     }
92941   }
92942   jresult = (void *)result;
92943   return jresult;
92944 }
92945
92946
92947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
92948   void * jresult ;
92949   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92950   Dali::Toolkit::Ruler *result = 0 ;
92951
92952   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92953   {
92954     try {
92955       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
92956     } catch (std::out_of_range& e) {
92957       {
92958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92959       };
92960     } catch (std::exception& e) {
92961       {
92962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92963       };
92964     } catch (...) {
92965       {
92966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92967       };
92968     }
92969   }
92970   jresult = (void *)result;
92971   return jresult;
92972 }
92973
92974
92975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
92976   void * jresult ;
92977   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92978   Dali::Toolkit::Ruler *result = 0 ;
92979
92980   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92981   {
92982     try {
92983       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
92984     } catch (std::out_of_range& e) {
92985       {
92986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92987       };
92988     } catch (std::exception& e) {
92989       {
92990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92991       };
92992     } catch (...) {
92993       {
92994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92995       };
92996     }
92997   }
92998   jresult = (void *)result;
92999   return jresult;
93000 }
93001
93002
93003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
93004   void * jresult ;
93005   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93006   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
93007   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93008
93009   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93010   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
93011   if (!arg2) {
93012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
93013     return 0;
93014   }
93015   {
93016     try {
93017       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
93018     } catch (std::out_of_range& e) {
93019       {
93020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93021       };
93022     } catch (std::exception& e) {
93023       {
93024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93025       };
93026     } catch (...) {
93027       {
93028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93029       };
93030     }
93031   }
93032   jresult = (void *)result;
93033   return jresult;
93034 }
93035
93036
93037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
93038   void * jresult ;
93039   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93040   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
93041   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93042
93043   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93044   arg2 = (Dali::Toolkit::Ruler *)jarg2;
93045   {
93046     try {
93047       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
93048     } catch (std::out_of_range& e) {
93049       {
93050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93051       };
93052     } catch (std::exception& e) {
93053       {
93054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93055       };
93056     } catch (...) {
93057       {
93058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93059       };
93060     }
93061   }
93062   jresult = (void *)result;
93063   return jresult;
93064 }
93065
93066
93067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
93068   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93069
93070   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93071   {
93072     try {
93073       (arg1)->Reset();
93074     } catch (std::out_of_range& e) {
93075       {
93076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93077       };
93078     } catch (std::exception& e) {
93079       {
93080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93081       };
93082     } catch (...) {
93083       {
93084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93085       };
93086     }
93087   }
93088 }
93089
93090
93091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
93092   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93093   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
93094
93095   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93096   arg2 = (Dali::Toolkit::Ruler *)jarg2;
93097   {
93098     try {
93099       (arg1)->Reset(arg2);
93100     } catch (std::out_of_range& e) {
93101       {
93102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93103       };
93104     } catch (std::exception& e) {
93105       {
93106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93107       };
93108     } catch (...) {
93109       {
93110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93111       };
93112     }
93113   }
93114 }
93115
93116
93117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
93118   void * jresult ;
93119   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93120   Dali::Toolkit::Ruler *result = 0 ;
93121
93122   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93123   {
93124     try {
93125       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
93126     } catch (std::out_of_range& e) {
93127       {
93128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93129       };
93130     } catch (std::exception& e) {
93131       {
93132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93133       };
93134     } catch (...) {
93135       {
93136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93137       };
93138     }
93139   }
93140   jresult = (void *)result;
93141   return jresult;
93142 }
93143
93144
93145 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
93146   float jresult ;
93147   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93148   float arg2 ;
93149   float arg3 ;
93150   float result;
93151
93152   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93153   arg2 = (float)jarg2;
93154   arg3 = (float)jarg3;
93155   {
93156     try {
93157       result = (float)(*arg1)->Snap(arg2,arg3);
93158     } catch (std::out_of_range& e) {
93159       {
93160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93161       };
93162     } catch (std::exception& e) {
93163       {
93164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93165       };
93166     } catch (...) {
93167       {
93168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93169       };
93170     }
93171   }
93172   jresult = result;
93173   return jresult;
93174 }
93175
93176
93177 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
93178   float jresult ;
93179   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93180   float arg2 ;
93181   float result;
93182
93183   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93184   arg2 = (float)jarg2;
93185   {
93186     try {
93187       result = (float)(*arg1)->Snap(arg2);
93188     } catch (std::out_of_range& e) {
93189       {
93190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93191       };
93192     } catch (std::exception& e) {
93193       {
93194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93195       };
93196     } catch (...) {
93197       {
93198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93199       };
93200     }
93201   }
93202   jresult = result;
93203   return jresult;
93204 }
93205
93206
93207 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
93208   float jresult ;
93209   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93210   unsigned int arg2 ;
93211   unsigned int *arg3 = 0 ;
93212   bool arg4 ;
93213   float result;
93214
93215   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93216   arg2 = (unsigned int)jarg2;
93217   arg3 = (unsigned int *)jarg3;
93218   arg4 = jarg4 ? true : false;
93219   {
93220     try {
93221       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
93222     } catch (std::out_of_range& e) {
93223       {
93224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93225       };
93226     } catch (std::exception& e) {
93227       {
93228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93229       };
93230     } catch (...) {
93231       {
93232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93233       };
93234     }
93235   }
93236   jresult = result;
93237   return jresult;
93238 }
93239
93240
93241 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
93242   unsigned int jresult ;
93243   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93244   float arg2 ;
93245   bool arg3 ;
93246   unsigned int result;
93247
93248   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93249   arg2 = (float)jarg2;
93250   arg3 = jarg3 ? true : false;
93251   {
93252     try {
93253       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
93254     } catch (std::out_of_range& e) {
93255       {
93256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93257       };
93258     } catch (std::exception& e) {
93259       {
93260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93261       };
93262     } catch (...) {
93263       {
93264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93265       };
93266     }
93267   }
93268   jresult = result;
93269   return jresult;
93270 }
93271
93272
93273 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
93274   unsigned int jresult ;
93275   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93276   unsigned int result;
93277
93278   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93279   {
93280     try {
93281       result = (unsigned int)(*arg1)->GetTotalPages();
93282     } catch (std::out_of_range& e) {
93283       {
93284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93285       };
93286     } catch (std::exception& e) {
93287       {
93288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93289       };
93290     } catch (...) {
93291       {
93292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93293       };
93294     }
93295   }
93296   jresult = result;
93297   return jresult;
93298 }
93299
93300
93301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
93302   int jresult ;
93303   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93304   Dali::Toolkit::Ruler::RulerType result;
93305
93306   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93307   {
93308     try {
93309       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
93310     } catch (std::out_of_range& e) {
93311       {
93312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93313       };
93314     } catch (std::exception& e) {
93315       {
93316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93317       };
93318     } catch (...) {
93319       {
93320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93321       };
93322     }
93323   }
93324   jresult = (int)result;
93325   return jresult;
93326 }
93327
93328
93329 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
93330   unsigned int jresult ;
93331   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93332   bool result;
93333
93334   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93335   {
93336     try {
93337       result = (bool)(*arg1)->IsEnabled();
93338     } catch (std::out_of_range& e) {
93339       {
93340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93341       };
93342     } catch (std::exception& e) {
93343       {
93344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93345       };
93346     } catch (...) {
93347       {
93348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93349       };
93350     }
93351   }
93352   jresult = result;
93353   return jresult;
93354 }
93355
93356
93357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
93358   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93359
93360   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93361   {
93362     try {
93363       (*arg1)->Enable();
93364     } catch (std::out_of_range& e) {
93365       {
93366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93367       };
93368     } catch (std::exception& e) {
93369       {
93370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93371       };
93372     } catch (...) {
93373       {
93374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93375       };
93376     }
93377   }
93378 }
93379
93380
93381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
93382   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93383
93384   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93385   {
93386     try {
93387       (*arg1)->Disable();
93388     } catch (std::out_of_range& e) {
93389       {
93390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93391       };
93392     } catch (std::exception& e) {
93393       {
93394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93395       };
93396     } catch (...) {
93397       {
93398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93399       };
93400     }
93401   }
93402 }
93403
93404
93405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
93406   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93407   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
93408   Dali::Toolkit::RulerDomain *argp2 ;
93409
93410   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93411   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
93412   if (!argp2) {
93413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
93414     return ;
93415   }
93416   arg2 = *argp2;
93417   {
93418     try {
93419       (*arg1)->SetDomain(arg2);
93420     } catch (std::out_of_range& e) {
93421       {
93422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93423       };
93424     } catch (std::exception& e) {
93425       {
93426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93427       };
93428     } catch (...) {
93429       {
93430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93431       };
93432     }
93433   }
93434 }
93435
93436
93437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
93438   void * jresult ;
93439   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93440   Dali::Toolkit::RulerDomain *result = 0 ;
93441
93442   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93443   {
93444     try {
93445       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
93446     } catch (std::out_of_range& e) {
93447       {
93448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93449       };
93450     } catch (std::exception& e) {
93451       {
93452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93453       };
93454     } catch (...) {
93455       {
93456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93457       };
93458     }
93459   }
93460   jresult = (void *)result;
93461   return jresult;
93462 }
93463
93464
93465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
93466   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93467
93468   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93469   {
93470     try {
93471       (*arg1)->DisableDomain();
93472     } catch (std::out_of_range& e) {
93473       {
93474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93475       };
93476     } catch (std::exception& e) {
93477       {
93478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93479       };
93480     } catch (...) {
93481       {
93482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93483       };
93484     }
93485   }
93486 }
93487
93488
93489 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
93490   float jresult ;
93491   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93492   float arg2 ;
93493   float arg3 ;
93494   float arg4 ;
93495   float result;
93496
93497   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93498   arg2 = (float)jarg2;
93499   arg3 = (float)jarg3;
93500   arg4 = (float)jarg4;
93501   {
93502     try {
93503       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
93504     } catch (std::out_of_range& e) {
93505       {
93506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93507       };
93508     } catch (std::exception& e) {
93509       {
93510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93511       };
93512     } catch (...) {
93513       {
93514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93515       };
93516     }
93517   }
93518   jresult = result;
93519   return jresult;
93520 }
93521
93522
93523 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
93524   float jresult ;
93525   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93526   float arg2 ;
93527   float arg3 ;
93528   float result;
93529
93530   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93531   arg2 = (float)jarg2;
93532   arg3 = (float)jarg3;
93533   {
93534     try {
93535       result = (float)(*arg1)->Clamp(arg2,arg3);
93536     } catch (std::out_of_range& e) {
93537       {
93538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93539       };
93540     } catch (std::exception& e) {
93541       {
93542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93543       };
93544     } catch (...) {
93545       {
93546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93547       };
93548     }
93549   }
93550   jresult = result;
93551   return jresult;
93552 }
93553
93554
93555 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
93556   float jresult ;
93557   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93558   float arg2 ;
93559   float result;
93560
93561   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93562   arg2 = (float)jarg2;
93563   {
93564     try {
93565       result = (float)(*arg1)->Clamp(arg2);
93566     } catch (std::out_of_range& e) {
93567       {
93568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93569       };
93570     } catch (std::exception& e) {
93571       {
93572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93573       };
93574     } catch (...) {
93575       {
93576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93577       };
93578     }
93579   }
93580   jresult = result;
93581   return jresult;
93582 }
93583
93584
93585 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
93586   float jresult ;
93587   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93588   float arg2 ;
93589   float arg3 ;
93590   float arg4 ;
93591   Dali::Toolkit::ClampState *arg5 = 0 ;
93592   float result;
93593
93594   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93595   arg2 = (float)jarg2;
93596   arg3 = (float)jarg3;
93597   arg4 = (float)jarg4;
93598   arg5 = (Dali::Toolkit::ClampState *)jarg5;
93599   if (!arg5) {
93600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
93601     return 0;
93602   }
93603   {
93604     try {
93605       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
93606     } catch (std::out_of_range& e) {
93607       {
93608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93609       };
93610     } catch (std::exception& e) {
93611       {
93612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93613       };
93614     } catch (...) {
93615       {
93616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93617       };
93618     }
93619   }
93620   jresult = result;
93621   return jresult;
93622 }
93623
93624
93625 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
93626   float jresult ;
93627   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93628   float arg2 ;
93629   float arg3 ;
93630   float arg4 ;
93631   float arg5 ;
93632   float result;
93633
93634   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93635   arg2 = (float)jarg2;
93636   arg3 = (float)jarg3;
93637   arg4 = (float)jarg4;
93638   arg5 = (float)jarg5;
93639   {
93640     try {
93641       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
93642     } catch (std::out_of_range& e) {
93643       {
93644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93645       };
93646     } catch (std::exception& e) {
93647       {
93648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93649       };
93650     } catch (...) {
93651       {
93652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93653       };
93654     }
93655   }
93656   jresult = result;
93657   return jresult;
93658 }
93659
93660
93661 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
93662   float jresult ;
93663   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93664   float arg2 ;
93665   float arg3 ;
93666   float arg4 ;
93667   float result;
93668
93669   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93670   arg2 = (float)jarg2;
93671   arg3 = (float)jarg3;
93672   arg4 = (float)jarg4;
93673   {
93674     try {
93675       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
93676     } catch (std::out_of_range& e) {
93677       {
93678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93679       };
93680     } catch (std::exception& e) {
93681       {
93682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93683       };
93684     } catch (...) {
93685       {
93686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93687       };
93688     }
93689   }
93690   jresult = result;
93691   return jresult;
93692 }
93693
93694
93695 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
93696   float jresult ;
93697   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93698   float arg2 ;
93699   float arg3 ;
93700   float result;
93701
93702   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93703   arg2 = (float)jarg2;
93704   arg3 = (float)jarg3;
93705   {
93706     try {
93707       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
93708     } catch (std::out_of_range& e) {
93709       {
93710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93711       };
93712     } catch (std::exception& e) {
93713       {
93714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93715       };
93716     } catch (...) {
93717       {
93718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93719       };
93720     }
93721   }
93722   jresult = result;
93723   return jresult;
93724 }
93725
93726
93727 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
93728   float jresult ;
93729   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93730   float arg2 ;
93731   float result;
93732
93733   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93734   arg2 = (float)jarg2;
93735   {
93736     try {
93737       result = (float)(*arg1)->SnapAndClamp(arg2);
93738     } catch (std::out_of_range& e) {
93739       {
93740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93741       };
93742     } catch (std::exception& e) {
93743       {
93744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93745       };
93746     } catch (...) {
93747       {
93748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93749       };
93750     }
93751   }
93752   jresult = result;
93753   return jresult;
93754 }
93755
93756
93757 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
93758   float jresult ;
93759   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93760   float arg2 ;
93761   float arg3 ;
93762   float arg4 ;
93763   float arg5 ;
93764   Dali::Toolkit::ClampState *arg6 = 0 ;
93765   float result;
93766
93767   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93768   arg2 = (float)jarg2;
93769   arg3 = (float)jarg3;
93770   arg4 = (float)jarg4;
93771   arg5 = (float)jarg5;
93772   arg6 = (Dali::Toolkit::ClampState *)jarg6;
93773   if (!arg6) {
93774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
93775     return 0;
93776   }
93777   {
93778     try {
93779       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
93780     } catch (std::out_of_range& e) {
93781       {
93782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93783       };
93784     } catch (std::exception& e) {
93785       {
93786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93787       };
93788     } catch (...) {
93789       {
93790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93791       };
93792     }
93793   }
93794   jresult = result;
93795   return jresult;
93796 }
93797
93798
93799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
93800   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93801
93802   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93803   {
93804     try {
93805       (*arg1)->Reference();
93806     } catch (std::out_of_range& e) {
93807       {
93808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93809       };
93810     } catch (std::exception& e) {
93811       {
93812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93813       };
93814     } catch (...) {
93815       {
93816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93817       };
93818     }
93819   }
93820 }
93821
93822
93823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
93824   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93825
93826   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93827   {
93828     try {
93829       (*arg1)->Unreference();
93830     } catch (std::out_of_range& e) {
93831       {
93832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93833       };
93834     } catch (std::exception& e) {
93835       {
93836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93837       };
93838     } catch (...) {
93839       {
93840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93841       };
93842     }
93843   }
93844 }
93845
93846
93847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
93848   int jresult ;
93849   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93850   int result;
93851
93852   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93853   {
93854     try {
93855       result = (int)(*arg1)->ReferenceCount();
93856     } catch (std::out_of_range& e) {
93857       {
93858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93859       };
93860     } catch (std::exception& e) {
93861       {
93862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93863       };
93864     } catch (...) {
93865       {
93866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93867       };
93868     }
93869   }
93870   jresult = result;
93871   return jresult;
93872 }
93873
93874
93875 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
93876   unsigned int jresult ;
93877   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93878   bool result;
93879
93880   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93881   {
93882     try {
93883       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
93884     } catch (std::out_of_range& e) {
93885       {
93886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93887       };
93888     } catch (std::exception& e) {
93889       {
93890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93891       };
93892     } catch (...) {
93893       {
93894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93895       };
93896     }
93897   }
93898   jresult = result;
93899   return jresult;
93900 }
93901
93902
93903 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
93904   unsigned long jresult ;
93905   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93906   std::size_t result;
93907
93908   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93909   {
93910     try {
93911       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
93912     } catch (std::out_of_range& e) {
93913       {
93914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93915       };
93916     } catch (std::exception& e) {
93917       {
93918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93919       };
93920     } catch (...) {
93921       {
93922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93923       };
93924     }
93925   }
93926   jresult = (unsigned long)result;
93927   return jresult;
93928 }
93929
93930
93931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
93932   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93933   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
93934
93935   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93936   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
93937   {
93938     try {
93939       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
93940     } catch (std::out_of_range& e) {
93941       {
93942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93943       };
93944     } catch (std::exception& e) {
93945       {
93946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93947       };
93948     } catch (...) {
93949       {
93950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93951       };
93952     }
93953   }
93954 }
93955
93956
93957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
93958   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93959   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
93960
93961   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93962   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
93963   {
93964     try {
93965       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
93966     } catch (std::out_of_range& e) {
93967       {
93968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93969       };
93970     } catch (std::exception& e) {
93971       {
93972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93973       };
93974     } catch (...) {
93975       {
93976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93977       };
93978     }
93979   }
93980 }
93981
93982
93983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
93984   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93985   Dali::Toolkit::Control arg2 ;
93986   Dali::Toolkit::Control *argp2 ;
93987
93988   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93989   argp2 = (Dali::Toolkit::Control *)jarg2;
93990   if (!argp2) {
93991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
93992     return ;
93993   }
93994   arg2 = *argp2;
93995   {
93996     try {
93997       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
93998     } catch (std::out_of_range& e) {
93999       {
94000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94001       };
94002     } catch (std::exception& e) {
94003       {
94004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94005       };
94006     } catch (...) {
94007       {
94008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94009       };
94010     }
94011   }
94012 }
94013
94014
94015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
94016   void * jresult ;
94017   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
94018
94019   {
94020     try {
94021       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
94022     } catch (std::out_of_range& e) {
94023       {
94024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94025       };
94026     } catch (std::exception& e) {
94027       {
94028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94029       };
94030     } catch (...) {
94031       {
94032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94033       };
94034     }
94035   }
94036   jresult = (void *)result;
94037   return jresult;
94038 }
94039
94040
94041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
94042   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
94043
94044   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
94045   {
94046     try {
94047       delete arg1;
94048     } catch (std::out_of_range& e) {
94049       {
94050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94051       };
94052     } catch (std::exception& e) {
94053       {
94054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94055       };
94056     } catch (...) {
94057       {
94058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94059       };
94060     }
94061   }
94062 }
94063
94064 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
94065     return (Dali::RefObject *)jarg1;
94066 }
94067
94068 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
94069     return (Dali::SignalObserver *)jarg1;
94070 }
94071
94072 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
94073     return (Dali::ConnectionTrackerInterface *)jarg1;
94074 }
94075
94076 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
94077     return (Dali::BaseHandle *)jarg1;
94078 }
94079
94080 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
94081     return (Dali::BaseHandle *)jarg1;
94082 }
94083
94084 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
94085     return (Dali::BaseHandle *)jarg1;
94086 }
94087
94088 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
94089     return (Dali::BaseHandle *)jarg1;
94090 }
94091
94092 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
94093     return (Dali::BaseHandle *)jarg1;
94094 }
94095
94096 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
94097     return (Dali::BaseHandle *)jarg1;
94098 }
94099
94100 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
94101     return (Dali::BaseHandle *)jarg1;
94102 }
94103
94104 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
94105     return (Dali::BaseHandle *)jarg1;
94106 }
94107
94108 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
94109     return (Dali::BaseHandle *)jarg1;
94110 }
94111
94112 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
94113     return (Dali::BaseHandle *)jarg1;
94114 }
94115
94116 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
94117     return (Dali::BaseHandle *)jarg1;
94118 }
94119
94120 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
94121     return (Dali::BaseHandle *)jarg1;
94122 }
94123
94124 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
94125     return (Dali::BaseHandle *)jarg1;
94126 }
94127
94128 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
94129     return (Dali::Handle *)jarg1;
94130 }
94131
94132 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
94133     return (Dali::Handle *)jarg1;
94134 }
94135
94136 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
94137     return (Dali::BaseHandle *)jarg1;
94138 }
94139
94140 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
94141     return (Dali::BaseHandle *)jarg1;
94142 }
94143
94144 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
94145     return (Dali::Handle *)jarg1;
94146 }
94147
94148 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
94149     return (Dali::BaseHandle *)jarg1;
94150 }
94151
94152 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
94153     return (Dali::Handle *)jarg1;
94154 }
94155
94156 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
94157     return (Dali::GestureDetector *)jarg1;
94158 }
94159
94160 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
94161     return (Dali::Gesture *)jarg1;
94162 }
94163
94164 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
94165     return (Dali::Handle *)jarg1;
94166 }
94167
94168 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
94169     return (Dali::Actor *)jarg1;
94170 }
94171
94172 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
94173     return (Dali::BaseHandle *)jarg1;
94174 }
94175
94176 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
94177     return (Dali::RefObject *)jarg1;
94178 }
94179
94180 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
94181     return (Dali::Actor *)jarg1;
94182 }
94183
94184 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
94185     return (Dali::GestureDetector *)jarg1;
94186 }
94187
94188 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
94189     return (Dali::Gesture *)jarg1;
94190 }
94191
94192 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
94193     return (Dali::GestureDetector *)jarg1;
94194 }
94195
94196 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
94197     return (Dali::Gesture *)jarg1;
94198 }
94199
94200 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
94201     return (Dali::GestureDetector *)jarg1;
94202 }
94203
94204 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
94205     return (Dali::Gesture *)jarg1;
94206 }
94207
94208 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
94209     return (Dali::BaseHandle *)jarg1;
94210 }
94211
94212 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
94213     return (Dali::Handle *)jarg1;
94214 }
94215
94216 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Animation_SWIGUpcast(Dali::Animation *jarg1) {
94217     return (Dali::BaseHandle *)jarg1;
94218 }
94219
94220 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
94221     return (Dali::Handle *)jarg1;
94222 }
94223
94224 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
94225     return (Dali::Handle *)jarg1;
94226 }
94227
94228 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
94229     return (Dali::Image *)jarg1;
94230 }
94231
94232 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
94233     return (Dali::Image *)jarg1;
94234 }
94235
94236 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
94237     return (Dali::Image *)jarg1;
94238 }
94239
94240 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
94241     return (Dali::RefObject *)jarg1;
94242 }
94243
94244 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
94245     return (Dali::Image *)jarg1;
94246 }
94247
94248 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
94249     return (Dali::Image *)jarg1;
94250 }
94251
94252 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
94253     return (Dali::ResourceImage *)jarg1;
94254 }
94255
94256 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
94257     return (Dali::Actor *)jarg1;
94258 }
94259
94260 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
94261     return (Dali::BaseHandle *)jarg1;
94262 }
94263
94264 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
94265     return (Dali::BaseHandle *)jarg1;
94266 }
94267
94268 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Window_SWIGUpcast(Dali::Window *jarg1) {
94269     return (Dali::BaseHandle *)jarg1;
94270 }
94271
94272 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Application_SWIGUpcast(Dali::Application *jarg1) {
94273     return (Dali::BaseHandle *)jarg1;
94274 }
94275
94276 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
94277     return (Dali::BaseHandle *)jarg1;
94278 }
94279
94280 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
94281     return (Dali::BaseHandle *)jarg1;
94282 }
94283
94284 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
94285     return (Dali::CustomActorImpl *)jarg1;
94286 }
94287
94288 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
94289     return (Dali::CustomActor *)jarg1;
94290 }
94291
94292 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
94293     return (Dali::BaseHandle *)jarg1;
94294 }
94295
94296 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
94297     return (Dali::Toolkit::Control *)jarg1;
94298 }
94299
94300 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
94301     return (Dali::Toolkit::Control *)jarg1;
94302 }
94303
94304 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
94305     return (Dali::Toolkit::Button *)jarg1;
94306 }
94307
94308 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
94309     return (Dali::Toolkit::Button *)jarg1;
94310 }
94311
94312 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
94313     return (Dali::Toolkit::Button *)jarg1;
94314 }
94315
94316 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
94317     return (Dali::Toolkit::Control *)jarg1;
94318 }
94319
94320 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
94321     return (Dali::Toolkit::Control *)jarg1;
94322 }
94323
94324 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
94325     return (Dali::Toolkit::Control *)jarg1;
94326 }
94327
94328 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
94329     return (Dali::Toolkit::Control *)jarg1;
94330 }
94331
94332 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
94333     return (Dali::Toolkit::Control *)jarg1;
94334 }
94335
94336 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
94337     return (Dali::RefObject *)jarg1;
94338 }
94339
94340 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
94341     return (Dali::Toolkit::Scrollable *)jarg1;
94342 }
94343
94344 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
94345     return (Dali::BaseHandle *)jarg1;
94346 }
94347
94348 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
94349     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
94350 }
94351
94352 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
94353     return (Dali::RefObject *)jarg1;
94354 }
94355
94356 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
94357     return (Dali::Toolkit::Ruler *)jarg1;
94358 }
94359
94360 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
94361     return (Dali::Toolkit::Ruler *)jarg1;
94362 }
94363
94364 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
94365     return (Dali::Toolkit::Scrollable *)jarg1;
94366 }
94367
94368 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
94369     return (Dali::Toolkit::Control *)jarg1;
94370 }
94371
94372 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextEditor_SWIGUpcast(Dali::Toolkit::TextEditor *jarg1) {
94373     return (Dali::Toolkit::Control *)jarg1;
94374 }
94375
94376 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextField_SWIGUpcast(Dali::Toolkit::TextField *jarg1) {
94377     return (Dali::Toolkit::Control *)jarg1;
94378 }
94379
94380 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
94381     return (Dali::Toolkit::Control *)jarg1;
94382 }
94383
94384 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
94385     return (Dali::BaseHandle *)jarg1;
94386 }
94387
94388 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
94389     return (Dali::BaseHandle *)jarg1;
94390 }
94391
94392 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
94393     return (Dali::Toolkit::Control *)jarg1;
94394 }
94395
94396 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
94397     return (Dali::Toolkit::Control *)jarg1;
94398 }
94399
94400 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
94401     return (Dali::Toolkit::Control *)jarg1;
94402 }
94403
94404 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
94405     return (Dali::Toolkit::Control *)jarg1;
94406 }
94407
94408 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
94409     return (Dali::Toolkit::Control *)jarg1;
94410 }
94411
94412 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
94413     return (Dali::Toolkit::Control *)jarg1;
94414 }
94415
94416 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
94417     return (Dali::Toolkit::PageTurnView *)jarg1;
94418 }
94419
94420 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
94421     return (Dali::Toolkit::PageTurnView *)jarg1;
94422 }
94423
94424 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
94425     return (Dali::Toolkit::Button *)jarg1;
94426 }
94427
94428 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
94429     return (Dali::BaseHandle *)jarg1;
94430 }
94431
94432 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
94433     return (Dali::BaseHandle *)jarg1;
94434 }
94435
94436 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
94437     return (Dali::BaseHandle *)jarg1;
94438 }
94439
94440
94441
94442
94443
94444 //////////////////////////////////////////////////
94445 //from dali-swig autogeneration (from dali_wrap.cpp)
94446
94447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfEventData__SWIG_0() {
94448   void * jresult ;
94449   Dali::ImfManager::ImfEventData *result = 0 ;
94450
94451   {
94452     try {
94453       result = (Dali::ImfManager::ImfEventData *)new Dali::ImfManager::ImfEventData();
94454     } catch (std::out_of_range& e) {
94455       {
94456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94457       };
94458     } catch (std::exception& e) {
94459       {
94460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94461       };
94462     } catch (...) {
94463       {
94464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94465       };
94466     }
94467   }
94468   jresult = (void *)result;
94469   return jresult;
94470 }
94471
94472
94473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfEventData__SWIG_1(int jarg1, char * jarg2, int jarg3, int jarg4) {
94474   void * jresult ;
94475   Dali::ImfManager::ImfEvent arg1 ;
94476   std::string *arg2 = 0 ;
94477   int arg3 ;
94478   int arg4 ;
94479   Dali::ImfManager::ImfEventData *result = 0 ;
94480
94481   arg1 = (Dali::ImfManager::ImfEvent)jarg1;
94482   if (!jarg2) {
94483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
94484     return 0;
94485   }
94486   std::string arg2_str(jarg2);
94487   arg2 = &arg2_str;
94488   arg3 = (int)jarg3;
94489   arg4 = (int)jarg4;
94490   {
94491     try {
94492       result = (Dali::ImfManager::ImfEventData *)new Dali::ImfManager::ImfEventData(arg1,(std::string const &)*arg2,arg3,arg4);
94493     } catch (std::out_of_range& e) {
94494       {
94495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94496       };
94497     } catch (std::exception& e) {
94498       {
94499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94500       };
94501     } catch (...) {
94502       {
94503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94504       };
94505     }
94506   }
94507   jresult = (void *)result;
94508
94509   //argout typemap for const std::string&
94510
94511   return jresult;
94512 }
94513
94514
94515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_predictiveString_set(void * jarg1, char * jarg2) {
94516   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94517   std::string *arg2 = 0 ;
94518
94519   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94520   if (!jarg2) {
94521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
94522     return ;
94523   }
94524   std::string arg2_str(jarg2);
94525   arg2 = &arg2_str;
94526   if (arg1) (arg1)->predictiveString = *arg2;
94527
94528   //argout typemap for const std::string&
94529
94530 }
94531
94532
94533 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_predictiveString_get(void * jarg1) {
94534   char * jresult ;
94535   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94536   std::string *result = 0 ;
94537
94538   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94539   result = (std::string *) & ((arg1)->predictiveString);
94540   jresult = SWIG_csharp_string_callback(result->c_str());
94541   return jresult;
94542 }
94543
94544
94545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_eventName_set(void * jarg1, int jarg2) {
94546   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94547   Dali::ImfManager::ImfEvent arg2 ;
94548
94549   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94550   arg2 = (Dali::ImfManager::ImfEvent)jarg2;
94551   if (arg1) (arg1)->eventName = arg2;
94552 }
94553
94554
94555 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_eventName_get(void * jarg1) {
94556   int jresult ;
94557   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94558   Dali::ImfManager::ImfEvent result;
94559
94560   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94561   result = (Dali::ImfManager::ImfEvent) ((arg1)->eventName);
94562   jresult = (int)result;
94563   return jresult;
94564 }
94565
94566
94567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_cursorOffset_set(void * jarg1, int jarg2) {
94568   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94569   int arg2 ;
94570
94571   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94572   arg2 = (int)jarg2;
94573   if (arg1) (arg1)->cursorOffset = arg2;
94574 }
94575
94576
94577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_cursorOffset_get(void * jarg1) {
94578   int jresult ;
94579   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94580   int result;
94581
94582   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94583   result = (int) ((arg1)->cursorOffset);
94584   jresult = result;
94585   return jresult;
94586 }
94587
94588
94589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_numberOfChars_set(void * jarg1, int jarg2) {
94590   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94591   int arg2 ;
94592
94593   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94594   arg2 = (int)jarg2;
94595   if (arg1) (arg1)->numberOfChars = arg2;
94596 }
94597
94598
94599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_numberOfChars_get(void * jarg1) {
94600   int jresult ;
94601   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94602   int result;
94603
94604   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94605   result = (int) ((arg1)->numberOfChars);
94606   jresult = result;
94607   return jresult;
94608 }
94609
94610
94611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImfManager_ImfEventData(void * jarg1) {
94612   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94613
94614   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94615   {
94616     try {
94617       delete arg1;
94618     } catch (std::out_of_range& e) {
94619       {
94620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94621       };
94622     } catch (std::exception& e) {
94623       {
94624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94625       };
94626     } catch (...) {
94627       {
94628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94629       };
94630     }
94631   }
94632 }
94633
94634
94635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfCallbackData__SWIG_0() {
94636   void * jresult ;
94637   Dali::ImfManager::ImfCallbackData *result = 0 ;
94638
94639   {
94640     try {
94641       result = (Dali::ImfManager::ImfCallbackData *)new Dali::ImfManager::ImfCallbackData();
94642     } catch (std::out_of_range& e) {
94643       {
94644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94645       };
94646     } catch (std::exception& e) {
94647       {
94648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94649       };
94650     } catch (...) {
94651       {
94652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94653       };
94654     }
94655   }
94656   jresult = (void *)result;
94657   return jresult;
94658 }
94659
94660
94661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfCallbackData__SWIG_1(unsigned int jarg1, int jarg2, char * jarg3, unsigned int jarg4) {
94662   void * jresult ;
94663   bool arg1 ;
94664   int arg2 ;
94665   std::string *arg3 = 0 ;
94666   bool arg4 ;
94667   Dali::ImfManager::ImfCallbackData *result = 0 ;
94668
94669   arg1 = jarg1 ? true : false;
94670   arg2 = (int)jarg2;
94671   if (!jarg3) {
94672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
94673     return 0;
94674   }
94675   std::string arg3_str(jarg3);
94676   arg3 = &arg3_str;
94677   arg4 = jarg4 ? true : false;
94678   {
94679     try {
94680       result = (Dali::ImfManager::ImfCallbackData *)new Dali::ImfManager::ImfCallbackData(arg1,arg2,(std::string const &)*arg3,arg4);
94681     } catch (std::out_of_range& e) {
94682       {
94683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94684       };
94685     } catch (std::exception& e) {
94686       {
94687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94688       };
94689     } catch (...) {
94690       {
94691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94692       };
94693     }
94694   }
94695   jresult = (void *)result;
94696
94697   //argout typemap for const std::string&
94698
94699   return jresult;
94700 }
94701
94702
94703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_currentText_set(void * jarg1, char * jarg2) {
94704   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94705   std::string *arg2 = 0 ;
94706
94707   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94708   if (!jarg2) {
94709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
94710     return ;
94711   }
94712   std::string arg2_str(jarg2);
94713   arg2 = &arg2_str;
94714   if (arg1) (arg1)->currentText = *arg2;
94715
94716   //argout typemap for const std::string&
94717
94718 }
94719
94720
94721 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_currentText_get(void * jarg1) {
94722   char * jresult ;
94723   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94724   std::string *result = 0 ;
94725
94726   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94727   result = (std::string *) & ((arg1)->currentText);
94728   jresult = SWIG_csharp_string_callback(result->c_str());
94729   return jresult;
94730 }
94731
94732
94733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_cursorPosition_set(void * jarg1, int jarg2) {
94734   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94735   int arg2 ;
94736
94737   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94738   arg2 = (int)jarg2;
94739   if (arg1) (arg1)->cursorPosition = arg2;
94740 }
94741
94742
94743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_cursorPosition_get(void * jarg1) {
94744   int jresult ;
94745   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94746   int result;
94747
94748   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94749   result = (int) ((arg1)->cursorPosition);
94750   jresult = result;
94751   return jresult;
94752 }
94753
94754
94755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_update_set(void * jarg1, unsigned int jarg2) {
94756   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94757   bool arg2 ;
94758
94759   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94760   arg2 = jarg2 ? true : false;
94761   if (arg1) (arg1)->update = arg2;
94762 }
94763
94764
94765 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_update_get(void * jarg1) {
94766   unsigned int jresult ;
94767   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94768   bool result;
94769
94770   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94771   result = (bool) ((arg1)->update);
94772   jresult = result;
94773   return jresult;
94774 }
94775
94776
94777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_preeditResetRequired_set(void * jarg1, unsigned int jarg2) {
94778   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94779   bool arg2 ;
94780
94781   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94782   arg2 = jarg2 ? true : false;
94783   if (arg1) (arg1)->preeditResetRequired = arg2;
94784 }
94785
94786
94787 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_preeditResetRequired_get(void * jarg1) {
94788   unsigned int jresult ;
94789   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94790   bool result;
94791
94792   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94793   result = (bool) ((arg1)->preeditResetRequired);
94794   jresult = result;
94795   return jresult;
94796 }
94797
94798
94799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImfManager_ImfCallbackData(void * jarg1) {
94800   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94801
94802   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94803   {
94804     try {
94805       delete arg1;
94806     } catch (std::out_of_range& e) {
94807       {
94808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94809       };
94810     } catch (std::exception& e) {
94811       {
94812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94813       };
94814     } catch (...) {
94815       {
94816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94817       };
94818     }
94819   }
94820 }
94821
94822
94823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_Get() {
94824   void * jresult ;
94825   Dali::ImfManager result;
94826
94827   {
94828     try {
94829       result = Dali::ImfManager::Get();
94830     } catch (std::out_of_range& e) {
94831       {
94832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94833       };
94834     } catch (std::exception& e) {
94835       {
94836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94837       };
94838     } catch (...) {
94839       {
94840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94841       };
94842     }
94843   }
94844   jresult = new Dali::ImfManager((const Dali::ImfManager &)result);
94845   return jresult;
94846 }
94847
94848
94849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_Activate(void * jarg1) {
94850   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94851
94852   arg1 = (Dali::ImfManager *)jarg1;
94853   {
94854     try {
94855       (arg1)->Activate();
94856     } catch (std::out_of_range& e) {
94857       {
94858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94859       };
94860     } catch (std::exception& e) {
94861       {
94862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94863       };
94864     } catch (...) {
94865       {
94866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94867       };
94868     }
94869   }
94870 }
94871
94872
94873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_Deactivate(void * jarg1) {
94874   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94875
94876   arg1 = (Dali::ImfManager *)jarg1;
94877   {
94878     try {
94879       (arg1)->Deactivate();
94880     } catch (std::out_of_range& e) {
94881       {
94882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94883       };
94884     } catch (std::exception& e) {
94885       {
94886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94887       };
94888     } catch (...) {
94889       {
94890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94891       };
94892     }
94893   }
94894 }
94895
94896
94897 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_RestoreAfterFocusLost(void * jarg1) {
94898   unsigned int jresult ;
94899   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94900   bool result;
94901
94902   arg1 = (Dali::ImfManager *)jarg1;
94903   {
94904     try {
94905       result = (bool)((Dali::ImfManager const *)arg1)->RestoreAfterFocusLost();
94906     } catch (std::out_of_range& e) {
94907       {
94908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94909       };
94910     } catch (std::exception& e) {
94911       {
94912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94913       };
94914     } catch (...) {
94915       {
94916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94917       };
94918     }
94919   }
94920   jresult = result;
94921   return jresult;
94922 }
94923
94924
94925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetRestoreAfterFocusLost(void * jarg1, unsigned int jarg2) {
94926   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94927   bool arg2 ;
94928
94929   arg1 = (Dali::ImfManager *)jarg1;
94930   arg2 = jarg2 ? true : false;
94931   {
94932     try {
94933       (arg1)->SetRestoreAfterFocusLost(arg2);
94934     } catch (std::out_of_range& e) {
94935       {
94936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94937       };
94938     } catch (std::exception& e) {
94939       {
94940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94941       };
94942     } catch (...) {
94943       {
94944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94945       };
94946     }
94947   }
94948 }
94949
94950
94951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_Reset(void * jarg1) {
94952   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94953
94954   arg1 = (Dali::ImfManager *)jarg1;
94955   {
94956     try {
94957       (arg1)->Reset();
94958     } catch (std::out_of_range& e) {
94959       {
94960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94961       };
94962     } catch (std::exception& e) {
94963       {
94964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94965       };
94966     } catch (...) {
94967       {
94968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94969       };
94970     }
94971   }
94972 }
94973
94974
94975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_NotifyCursorPosition(void * jarg1) {
94976   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94977
94978   arg1 = (Dali::ImfManager *)jarg1;
94979   {
94980     try {
94981       (arg1)->NotifyCursorPosition();
94982     } catch (std::out_of_range& e) {
94983       {
94984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94985       };
94986     } catch (std::exception& e) {
94987       {
94988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94989       };
94990     } catch (...) {
94991       {
94992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94993       };
94994     }
94995   }
94996 }
94997
94998
94999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetCursorPosition(void * jarg1, unsigned int jarg2) {
95000   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95001   unsigned int arg2 ;
95002
95003   arg1 = (Dali::ImfManager *)jarg1;
95004   arg2 = (unsigned int)jarg2;
95005   {
95006     try {
95007       (arg1)->SetCursorPosition(arg2);
95008     } catch (std::out_of_range& e) {
95009       {
95010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95011       };
95012     } catch (std::exception& e) {
95013       {
95014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95015       };
95016     } catch (...) {
95017       {
95018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95019       };
95020     }
95021   }
95022 }
95023
95024
95025 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_GetCursorPosition(void * jarg1) {
95026   unsigned int jresult ;
95027   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95028   unsigned int result;
95029
95030   arg1 = (Dali::ImfManager *)jarg1;
95031   {
95032     try {
95033       result = (unsigned int)((Dali::ImfManager const *)arg1)->GetCursorPosition();
95034     } catch (std::out_of_range& e) {
95035       {
95036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95037       };
95038     } catch (std::exception& e) {
95039       {
95040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95041       };
95042     } catch (...) {
95043       {
95044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95045       };
95046     }
95047   }
95048   jresult = result;
95049   return jresult;
95050 }
95051
95052
95053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetSurroundingText(void * jarg1, char * jarg2) {
95054   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95055   std::string *arg2 = 0 ;
95056
95057   arg1 = (Dali::ImfManager *)jarg1;
95058   if (!jarg2) {
95059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95060     return ;
95061   }
95062   std::string arg2_str(jarg2);
95063   arg2 = &arg2_str;
95064   {
95065     try {
95066       (arg1)->SetSurroundingText((std::string const &)*arg2);
95067     } catch (std::out_of_range& e) {
95068       {
95069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95070       };
95071     } catch (std::exception& e) {
95072       {
95073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95074       };
95075     } catch (...) {
95076       {
95077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95078       };
95079     }
95080   }
95081
95082   //argout typemap for const std::string&
95083
95084 }
95085
95086
95087 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImfManager_GetSurroundingText(void * jarg1) {
95088   char * jresult ;
95089   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95090   std::string *result = 0 ;
95091
95092   arg1 = (Dali::ImfManager *)jarg1;
95093   {
95094     try {
95095       result = (std::string *) &((Dali::ImfManager const *)arg1)->GetSurroundingText();
95096     } catch (std::out_of_range& e) {
95097       {
95098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95099       };
95100     } catch (std::exception& e) {
95101       {
95102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95103       };
95104     } catch (...) {
95105       {
95106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95107       };
95108     }
95109   }
95110   jresult = SWIG_csharp_string_callback(result->c_str());
95111   return jresult;
95112 }
95113
95114
95115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_NotifyTextInputMultiLine(void * jarg1, unsigned int jarg2) {
95116   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95117   bool arg2 ;
95118
95119   arg1 = (Dali::ImfManager *)jarg1;
95120   arg2 = jarg2 ? true : false;
95121   {
95122     try {
95123       (arg1)->NotifyTextInputMultiLine(arg2);
95124     } catch (std::out_of_range& e) {
95125       {
95126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95127       };
95128     } catch (std::exception& e) {
95129       {
95130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95131       };
95132     } catch (...) {
95133       {
95134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95135       };
95136     }
95137   }
95138 }
95139
95140
95141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_GetTextDirection(void * jarg1) {
95142   int jresult ;
95143   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95144   Dali::ImfManager::TextDirection result;
95145
95146   arg1 = (Dali::ImfManager *)jarg1;
95147   {
95148     try {
95149       result = (Dali::ImfManager::TextDirection)(arg1)->GetTextDirection();
95150     } catch (std::out_of_range& e) {
95151       {
95152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95153       };
95154     } catch (std::exception& e) {
95155       {
95156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95157       };
95158     } catch (...) {
95159       {
95160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95161       };
95162     }
95163   }
95164   jresult = (int)result;
95165   return jresult;
95166 }
95167
95168
95169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_GetInputMethodArea(void * jarg1) {
95170   void * jresult ;
95171   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95172   Dali::Rect< int > result;
95173
95174   arg1 = (Dali::ImfManager *)jarg1;
95175   {
95176     try {
95177       result = (arg1)->GetInputMethodArea();
95178     } catch (std::out_of_range& e) {
95179       {
95180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95181       };
95182     } catch (std::exception& e) {
95183       {
95184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95185       };
95186     } catch (...) {
95187       {
95188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95189       };
95190     }
95191   }
95192   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
95193   return jresult;
95194 }
95195
95196
95197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ApplyOptions(void * jarg1, void * jarg2) {
95198   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95199   Dali::InputMethodOptions *arg2 = 0 ;
95200
95201   arg1 = (Dali::ImfManager *)jarg1;
95202   arg2 = (Dali::InputMethodOptions *)jarg2;
95203   if (!arg2) {
95204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InputMethodOptions const & type is null", 0);
95205     return ;
95206   }
95207   {
95208     try {
95209       (arg1)->ApplyOptions((Dali::InputMethodOptions const &)*arg2);
95210     } catch (std::out_of_range& e) {
95211       {
95212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95213       };
95214     } catch (std::exception& e) {
95215       {
95216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95217       };
95218     } catch (...) {
95219       {
95220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95221       };
95222     }
95223   }
95224 }
95225
95226
95227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetInputPanelUserData(void * jarg1, char * jarg2) {
95228   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95229   std::string *arg2 = 0 ;
95230
95231   arg1 = (Dali::ImfManager *)jarg1;
95232   if (!jarg2) {
95233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95234     return ;
95235   }
95236   std::string arg2_str(jarg2);
95237   arg2 = &arg2_str;
95238   {
95239     try {
95240       (arg1)->SetInputPanelUserData((std::string const &)*arg2);
95241     } catch (std::out_of_range& e) {
95242       {
95243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95244       };
95245     } catch (std::exception& e) {
95246       {
95247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95248       };
95249     } catch (...) {
95250       {
95251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95252       };
95253     }
95254   }
95255
95256   //argout typemap for const std::string&
95257
95258 }
95259
95260
95261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_GetInputPanelUserData(void * jarg1, char * jarg2) {
95262   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95263   std::string *arg2 = 0 ;
95264
95265   arg1 = (Dali::ImfManager *)jarg1;
95266   if (!jarg2) {
95267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95268     return ;
95269   }
95270   std::string arg2_str(jarg2);
95271   arg2 = &arg2_str;
95272   {
95273     try {
95274       (arg1)->GetInputPanelUserData((std::string &)*arg2);
95275     } catch (std::out_of_range& e) {
95276       {
95277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95278       };
95279     } catch (std::exception& e) {
95280       {
95281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95282       };
95283     } catch (...) {
95284       {
95285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95286       };
95287     }
95288   }
95289
95290 }
95291
95292
95293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_GetInputPanelState(void * jarg1) {
95294   int jresult ;
95295   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95296   Dali::ImfManager::State result;
95297
95298   arg1 = (Dali::ImfManager *)jarg1;
95299   {
95300     try {
95301       result = (Dali::ImfManager::State)(arg1)->GetInputPanelState();
95302     } catch (std::out_of_range& e) {
95303       {
95304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95305       };
95306     } catch (std::exception& e) {
95307       {
95308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95309       };
95310     } catch (...) {
95311       {
95312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95313       };
95314     }
95315   }
95316   jresult = (int)result;
95317   return jresult;
95318 }
95319
95320
95321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetReturnKeyState(void * jarg1, unsigned int jarg2) {
95322   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95323   bool arg2 ;
95324
95325   arg1 = (Dali::ImfManager *)jarg1;
95326   arg2 = jarg2 ? true : false;
95327   {
95328     try {
95329       (arg1)->SetReturnKeyState(arg2);
95330     } catch (std::out_of_range& e) {
95331       {
95332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95333       };
95334     } catch (std::exception& e) {
95335       {
95336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95337       };
95338     } catch (...) {
95339       {
95340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95341       };
95342     }
95343   }
95344 }
95345
95346
95347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_AutoEnableInputPanel(void * jarg1, unsigned int jarg2) {
95348   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95349   bool arg2 ;
95350
95351   arg1 = (Dali::ImfManager *)jarg1;
95352   arg2 = jarg2 ? true : false;
95353   {
95354     try {
95355       (arg1)->AutoEnableInputPanel(arg2);
95356     } catch (std::out_of_range& e) {
95357       {
95358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95359       };
95360     } catch (std::exception& e) {
95361       {
95362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95363       };
95364     } catch (...) {
95365       {
95366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95367       };
95368     }
95369   }
95370 }
95371
95372
95373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ShowInputPanel(void * jarg1) {
95374   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95375
95376   arg1 = (Dali::ImfManager *)jarg1;
95377   {
95378     try {
95379       (arg1)->ShowInputPanel();
95380     } catch (std::out_of_range& e) {
95381       {
95382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95383       };
95384     } catch (std::exception& e) {
95385       {
95386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95387       };
95388     } catch (...) {
95389       {
95390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95391       };
95392     }
95393   }
95394 }
95395
95396
95397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_HideInputPanel(void * jarg1) {
95398   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95399
95400   arg1 = (Dali::ImfManager *)jarg1;
95401   {
95402     try {
95403       (arg1)->HideInputPanel();
95404     } catch (std::out_of_range& e) {
95405       {
95406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95407       };
95408     } catch (std::exception& e) {
95409       {
95410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95411       };
95412     } catch (...) {
95413       {
95414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95415       };
95416     }
95417   }
95418 }
95419
95420
95421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_ActivatedSignal(void * jarg1) {
95422   void * jresult ;
95423   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95424   Dali::ImfManager::ImfManagerSignalType *result = 0 ;
95425
95426   arg1 = (Dali::ImfManager *)jarg1;
95427   {
95428     try {
95429       result = (Dali::ImfManager::ImfManagerSignalType *) &(arg1)->ActivatedSignal();
95430     } catch (std::out_of_range& e) {
95431       {
95432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95433       };
95434     } catch (std::exception& e) {
95435       {
95436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95437       };
95438     } catch (...) {
95439       {
95440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95441       };
95442     }
95443   }
95444   jresult = (void *)result;
95445   return jresult;
95446 }
95447
95448
95449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_EventReceivedSignal(void * jarg1) {
95450   void * jresult ;
95451   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95452   Dali::ImfManager::ImfEventSignalType *result = 0 ;
95453
95454   arg1 = (Dali::ImfManager *)jarg1;
95455   {
95456     try {
95457       result = (Dali::ImfManager::ImfEventSignalType *) &(arg1)->EventReceivedSignal();
95458     } catch (std::out_of_range& e) {
95459       {
95460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95461       };
95462     } catch (std::exception& e) {
95463       {
95464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95465       };
95466     } catch (...) {
95467       {
95468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95469       };
95470     }
95471   }
95472   jresult = (void *)result;
95473   return jresult;
95474 }
95475
95476
95477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_StatusChangedSignal(void * jarg1) {
95478   void * jresult ;
95479   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95480   Dali::ImfManager::StatusSignalType *result = 0 ;
95481
95482   arg1 = (Dali::ImfManager *)jarg1;
95483   {
95484     try {
95485       result = (Dali::ImfManager::StatusSignalType *) &(arg1)->StatusChangedSignal();
95486     } catch (std::out_of_range& e) {
95487       {
95488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95489       };
95490     } catch (std::exception& e) {
95491       {
95492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95493       };
95494     } catch (...) {
95495       {
95496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95497       };
95498     }
95499   }
95500   jresult = (void *)result;
95501   return jresult;
95502 }
95503
95504
95505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_ResizedSignal(void * jarg1) {
95506   void * jresult ;
95507   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95508   Dali::ImfManager::VoidSignalType *result = 0 ;
95509
95510   arg1 = (Dali::ImfManager *)jarg1;
95511   {
95512     try {
95513       result = (Dali::ImfManager::VoidSignalType *) &(arg1)->ResizedSignal();
95514     } catch (std::out_of_range& e) {
95515       {
95516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95517       };
95518     } catch (std::exception& e) {
95519       {
95520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95521       };
95522     } catch (...) {
95523       {
95524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95525       };
95526     }
95527   }
95528   jresult = (void *)result;
95529   return jresult;
95530 }
95531
95532
95533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_LanguageChangedSignal(void * jarg1) {
95534   void * jresult ;
95535   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95536   Dali::ImfManager::VoidSignalType *result = 0 ;
95537
95538   arg1 = (Dali::ImfManager *)jarg1;
95539   {
95540     try {
95541       result = (Dali::ImfManager::VoidSignalType *) &(arg1)->LanguageChangedSignal();
95542     } catch (std::out_of_range& e) {
95543       {
95544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95545       };
95546     } catch (std::exception& e) {
95547       {
95548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95549       };
95550     } catch (...) {
95551       {
95552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95553       };
95554     }
95555   }
95556   jresult = (void *)result;
95557   return jresult;
95558 }
95559
95560
95561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager__SWIG_0() {
95562   void * jresult ;
95563   Dali::ImfManager *result = 0 ;
95564
95565   {
95566     try {
95567       result = (Dali::ImfManager *)new Dali::ImfManager();
95568     } catch (std::out_of_range& e) {
95569       {
95570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95571       };
95572     } catch (std::exception& e) {
95573       {
95574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95575       };
95576     } catch (...) {
95577       {
95578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95579       };
95580     }
95581   }
95582   jresult = (void *)result;
95583   return jresult;
95584 }
95585
95586
95587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImfManager(void * jarg1) {
95588   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95589
95590   arg1 = (Dali::ImfManager *)jarg1;
95591   {
95592     try {
95593       delete arg1;
95594     } catch (std::out_of_range& e) {
95595       {
95596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95597       };
95598     } catch (std::exception& e) {
95599       {
95600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95601       };
95602     } catch (...) {
95603       {
95604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95605       };
95606     }
95607   }
95608 }
95609
95610
95611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager__SWIG_1(void * jarg1) {
95612   void * jresult ;
95613   Dali::Internal::Adaptor::ImfManager *arg1 = (Dali::Internal::Adaptor::ImfManager *) 0 ;
95614   Dali::ImfManager *result = 0 ;
95615
95616   arg1 = (Dali::Internal::Adaptor::ImfManager *)jarg1;
95617   {
95618     try {
95619       result = (Dali::ImfManager *)new Dali::ImfManager(arg1);
95620     } catch (std::out_of_range& e) {
95621       {
95622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95623       };
95624     } catch (std::exception& e) {
95625       {
95626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95627       };
95628     } catch (...) {
95629       {
95630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95631       };
95632     }
95633   }
95634   jresult = (void *)result;
95635   return jresult;
95636 }
95637
95638
95639 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ImfManager_SWIGUpcast(Dali::ImfManager *jarg1) {
95640     return (Dali::BaseHandle *)jarg1;
95641 }
95642
95643
95644 //////////////////////////////////////////////////
95645 //from dali-swig autogeneration (from dali_wrap.cpp)
95646
95647
95648
95649
95650
95651
95652
95653
95654
95655
95656
95657
95658 #ifdef __cplusplus
95659 }
95660 #endif
95661