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 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
 426 #include <dali/devel-api/actors/actor-devel.h>
 427
 428 #include <dali/public-api/math/matrix.h>
 429 #include <dali/public-api/math/matrix3.h>
 430 #include <dali/public-api/math/viewport.h>
 431 #include <dali/public-api/object/property-key.h>
 432 #include <dali/devel-api/object/csharp-type-info.h>
 433 #include <dali/devel-api/object/csharp-type-registry.h>
 434
 435 #include <dali/public-api/adaptor-framework/timer.h>
 436 #include <dali/public-api/adaptor-framework/style-change.h>
 437 #include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
 438 #include <dali/devel-api/adaptor-framework/application-extensions.h>
 439
 440 #include <dali/devel-api/images/nine-patch-image.h>
 441
 442 #include <dali-toolkit/devel-api/builder/builder.h>
 443
 444 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 445 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 446
 447 #include <dali-toolkit/devel-api/controls/control-devel.h>
 448 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 449 #include <dali-toolkit/devel-api/controls/progress-bar/progress-bar.h>
 450 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 451 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 455 #include <dali-toolkit/devel-api/controls/scrollable/scroll-view/scroll-view-devel.h>
 456 #include <dali-toolkit/devel-api/controls/text-controls/text-label-devel.h>
 457 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 458
 459 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 460 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 461 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 462
 463 #include <dali-toolkit/devel-api/visuals/text-visual-properties.h>
 464 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.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
 471
 472 // add here SWIG version check
 473
 474 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 475 // disable Swig-dependent warnings
 476
 477 // 'identifier1' has C-linkage specified,
 478 // but returns UDT 'identifier2' which is incompatible with C
 479 #pragma warning(disable: 4190)
 480
 481 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 482 #pragma warning(disable: 4800)
 483
 484 // debug info too long etc etc
 485 #pragma warning(disable: 4786)
 486 #endif
 487
 488
 489 #include <stdexcept>
 490
 491
 492 #include <string>
 493
 494
 495 #include <vector>
 496 #include <algorithm>
 497 #include <stdexcept>
 498
 499
 500 #include <map>
 501 #include <algorithm>
 502 #include <stdexcept>
 503
 504
 505 #include <utility>
 506
 507
 508 typedef float floatp;
 509
 510 SWIGINTERN floatp *new_floatp(){
 511   return new float();
 512 }
 513 SWIGINTERN void delete_floatp(floatp *self){
 514   if (self) delete self;
 515 }
 516 SWIGINTERN void floatp_assign(floatp *self,float value){
 517   *self = value;
 518 }
 519 SWIGINTERN float floatp_value(floatp *self){
 520   return *self;
 521 }
 522 SWIGINTERN float *floatp_cast(floatp *self){
 523   return self;
 524 }
 525 SWIGINTERN floatp *floatp_frompointer(float *t){
 526   return (floatp *) t;
 527 }
 528
 529 typedef int intp;
 530
 531 SWIGINTERN intp *new_intp(){
 532   return new int();
 533 }
 534 SWIGINTERN void delete_intp(intp *self){
 535   if (self) delete self;
 536 }
 537 SWIGINTERN void intp_assign(intp *self,int value){
 538   *self = value;
 539 }
 540 SWIGINTERN int intp_value(intp *self){
 541   return *self;
 542 }
 543 SWIGINTERN int *intp_cast(intp *self){
 544   return self;
 545 }
 546 SWIGINTERN intp *intp_frompointer(int *t){
 547   return (intp *) t;
 548 }
 549
 550 typedef double doublep;
 551
 552 SWIGINTERN doublep *new_doublep(){
 553   return new double();
 554 }
 555 SWIGINTERN void delete_doublep(doublep *self){
 556   if (self) delete self;
 557 }
 558 SWIGINTERN void doublep_assign(doublep *self,double value){
 559   *self = value;
 560 }
 561 SWIGINTERN double doublep_value(doublep *self){
 562   return *self;
 563 }
 564 SWIGINTERN double *doublep_cast(doublep *self){
 565   return self;
 566 }
 567 SWIGINTERN doublep *doublep_frompointer(double *t){
 568   return (doublep *) t;
 569 }
 570
 571 typedef unsigned int uintp;
 572
 573 SWIGINTERN uintp *new_uintp(){
 574   return new unsigned int();
 575 }
 576 SWIGINTERN void delete_uintp(uintp *self){
 577   if (self) delete self;
 578 }
 579 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 580   *self = value;
 581 }
 582 SWIGINTERN unsigned int uintp_value(uintp *self){
 583   return *self;
 584 }
 585 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 586   return self;
 587 }
 588 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 589   return (uintp *) t;
 590 }
 591
 592 typedef unsigned short ushortp;
 593
 594 SWIGINTERN ushortp *new_ushortp(){
 595   return new unsigned short();
 596 }
 597 SWIGINTERN void delete_ushortp(ushortp *self){
 598   if (self) delete self;
 599 }
 600 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 601   *self = value;
 602 }
 603 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 604   return *self;
 605 }
 606 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 607   return self;
 608 }
 609 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 610   return (ushortp *) t;
 611 }
 612
 613 unsigned int int_to_uint(int x) {
 614    return (unsigned int) x;
 615 }
 616
 617
 618 using namespace Dali;
 619 using namespace Dali::Toolkit;
 620
 621 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self){
 622
 623      // C++ code. DALi uses Handle <-> Body design pattern.
 624      // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 625      // Handles in DALi can be converted into a boolean type
 626      // to check if the handle has a valid body attached to it.
 627      // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 628      if( *self )
 629      {
 630        return true;
 631      }
 632      else
 633      {
 634        return false;
 635      }
 636     }
 637 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs){
 638
 639      // C++ code. Check if two handles reference the same implemtion
 640      if( *self == rhs)
 641      {
 642        return true;
 643      }
 644      else
 645      {
 646        return false;
 647      }
 648     }
 649 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 650      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 651    }
 652 SWIGINTERN void Dali_TypeRegistration_RegisterProperty(std::string const &controlName,std::string const &propertyName,int index,Dali::Property::Type type,Dali::CSharpTypeInfo::SetPropertyFunction setFunc,Dali::CSharpTypeInfo::GetPropertyFunction getFunc){
 653      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 654    }
 655 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 656         std::vector< Dali::TouchPoint >* pv = 0;
 657         if (capacity >= 0) {
 658           pv = new std::vector< Dali::TouchPoint >();
 659           pv->reserve(capacity);
 660        } else {
 661           throw std::out_of_range("capacity");
 662        }
 663        return pv;
 664       }
 665 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 666         if (index>=0 && index<(int)self->size())
 667           return (*self)[index];
 668         else
 669           throw std::out_of_range("index");
 670       }
 671 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 672         if (index>=0 && index<(int)self->size())
 673           return (*self)[index];
 674         else
 675           throw std::out_of_range("index");
 676       }
 677 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 678         if (index>=0 && index<(int)self->size())
 679           (*self)[index] = val;
 680         else
 681           throw std::out_of_range("index");
 682       }
 683 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 684         self->insert(self->end(), values.begin(), values.end());
 685       }
 686 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 687         if (index < 0)
 688           throw std::out_of_range("index");
 689         if (count < 0)
 690           throw std::out_of_range("count");
 691         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 692           throw std::invalid_argument("invalid range");
 693         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 694       }
 695 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 696         if (index>=0 && index<(int)self->size()+1)
 697           self->insert(self->begin()+index, x);
 698         else
 699           throw std::out_of_range("index");
 700       }
 701 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 702         if (index>=0 && index<(int)self->size()+1)
 703           self->insert(self->begin()+index, values.begin(), values.end());
 704         else
 705           throw std::out_of_range("index");
 706       }
 707 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 708         if (index>=0 && index<(int)self->size())
 709           self->erase(self->begin() + index);
 710         else
 711           throw std::out_of_range("index");
 712       }
 713 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 714         if (index < 0)
 715           throw std::out_of_range("index");
 716         if (count < 0)
 717           throw std::out_of_range("count");
 718         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 719           throw std::invalid_argument("invalid range");
 720         self->erase(self->begin()+index, self->begin()+index+count);
 721       }
 722 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 723         if (count < 0)
 724           throw std::out_of_range("count");
 725         return new std::vector< Dali::TouchPoint >(count, value);
 726       }
 727 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 728         std::reverse(self->begin(), self->end());
 729       }
 730 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 731         if (index < 0)
 732           throw std::out_of_range("index");
 733         if (count < 0)
 734           throw std::out_of_range("count");
 735         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 736           throw std::invalid_argument("invalid range");
 737         std::reverse(self->begin()+index, self->begin()+index+count);
 738       }
 739 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 740         if (index < 0)
 741           throw std::out_of_range("index");
 742         if (index+values.size() > self->size())
 743           throw std::out_of_range("index");
 744         std::copy(values.begin(), values.end(), self->begin()+index);
 745       }
 746 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 747          return self->Empty();
 748       }
 749 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 750         return self->GetConnectionCount();
 751       }
 752 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 753           self->Connect( func );
 754       }
 755 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 756           self->Disconnect( func );
 757       }
 758 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 759           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 760 /*@SWIG@*/ self->Emit( arg );
 761       }
 762 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 763          return self->Empty();
 764       }
 765 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 766         return self->GetConnectionCount();
 767       }
 768 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 769           self->Connect( func );
 770       }
 771 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 772           self->Disconnect( func );
 773       }
 774 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 775           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 776 /*@SWIG@*/ self->Emit( arg );
 777       }
 778 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 779          return self->Empty();
 780       }
 781 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::RefObject const *) > const *self){
 782         return self->GetConnectionCount();
 783       }
 784 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 785           self->Connect( func );
 786       }
 787 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 788           self->Disconnect( func );
 789       }
 790 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(Dali::Signal< void (Dali::RefObject const *) > *self,Dali::RefObject const *arg){
 791           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 792 /*@SWIG@*/ self->Emit( arg );
 793       }
 794 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 795          return self->Empty();
 796       }
 797 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 798         return self->GetConnectionCount();
 799       }
 800 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 801           self->Connect( func );
 802       }
 803 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 804           self->Disconnect( func );
 805       }
 806 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 807           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 808 /*@SWIG@*/ self->Emit( arg );
 809       }
 810 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 811          return self->Empty();
 812       }
 813 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 814         return self->GetConnectionCount();
 815       }
 816 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 817           self->Connect( func );
 818       }
 819 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 820           self->Disconnect( func );
 821       }
 822 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 823           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 824 /*@SWIG@*/ self->Emit( arg );
 825       }
 826 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 827          return self->Empty();
 828       }
 829 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 830         return self->GetConnectionCount();
 831       }
 832 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 833         self->Connect( func );
 834       }
 835 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 836         self->Disconnect( func );
 837       }
 838 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,Dali::Actor arg1,Dali::LongPressGesture const &arg2){
 839         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 840 /*@SWIG@*/ self->Emit( arg1, arg2 );
 841       }
 842 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
 843          return self->Empty();
 844       }
 845 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
 846         return self->GetConnectionCount();
 847       }
 848 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
 849         self->Connect( func );
 850       }
 851 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
 852         self->Disconnect( func );
 853       }
 854 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,Dali::Actor arg1,Dali::TouchData const &arg2){
 855         return self->Emit( arg1, arg2 );
 856       }
 857 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 858          return self->Empty();
 859       }
 860 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 861         return self->GetConnectionCount();
 862       }
 863 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 864         self->Connect( func );
 865       }
 866 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 867         self->Disconnect( func );
 868       }
 869 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,Dali::Actor arg1,Dali::HoverEvent const &arg2){
 870         return self->Emit( arg1, arg2 );
 871       }
 872 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 873          return self->Empty();
 874       }
 875 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 876         return self->GetConnectionCount();
 877       }
 878 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 879         self->Connect( func );
 880       }
 881 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 882         self->Disconnect( func );
 883       }
 884 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,Dali::Actor arg1,Dali::WheelEvent const &arg2){
 885         return self->Emit( arg1, arg2 );
 886       }
 887 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 888          return self->Empty();
 889       }
 890 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 891         return self->GetConnectionCount();
 892       }
 893 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 894           self->Connect( func );
 895       }
 896 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 897           self->Disconnect( func );
 898       }
 899 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 900           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 901 /*@SWIG@*/ self->Emit( arg );
 902       }
 903 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 904          return self->Empty();
 905       }
 906 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 907         return self->GetConnectionCount();
 908       }
 909 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 910           self->Connect( func );
 911       }
 912 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 913           self->Disconnect( func );
 914       }
 915 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::KeyEvent const &) > *self,Dali::KeyEvent const &arg){
 916           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 917 /*@SWIG@*/ self->Emit( arg );
 918       }
 919 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 920          return self->Empty();
 921       }
 922 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::TouchData const &) > const *self){
 923         return self->GetConnectionCount();
 924       }
 925 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
 926           self->Connect( func );
 927       }
 928 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
 929           self->Disconnect( func );
 930       }
 931 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::TouchData const &) > *self,Dali::TouchData const &arg){
 932           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 933 /*@SWIG@*/ self->Emit( arg );
 934       }
 935 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 936          return self->Empty();
 937       }
 938 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 939         return self->GetConnectionCount();
 940       }
 941 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
 942           self->Connect( func );
 943       }
 944 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
 945           self->Disconnect( func );
 946       }
 947 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::WheelEvent const &) > *self,Dali::WheelEvent const &arg){
 948           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 949 /*@SWIG@*/ self->Emit( arg );
 950       }
 951 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
 952          return self->Empty();
 953       }
 954 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
 955         return self->GetConnectionCount();
 956       }
 957 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
 958         self->Connect( func );
 959       }
 960 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
 961         self->Disconnect( func );
 962       }
 963 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,Dali::Actor arg1,Dali::PanGesture const &arg2){
 964         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 965 /*@SWIG@*/ self->Emit( arg1, arg2 );
 966       }
 967 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
 968          return self->Empty();
 969       }
 970 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
 971         return self->GetConnectionCount();
 972       }
 973 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
 974         self->Connect( func );
 975       }
 976 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
 977         self->Disconnect( func );
 978       }
 979 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,Dali::Actor arg1,Dali::PinchGesture const &arg2){
 980         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 981 /*@SWIG@*/ self->Emit( arg1, arg2 );
 982       }
 983 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
 984          return self->Empty();
 985       }
 986 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
 987         return self->GetConnectionCount();
 988       }
 989 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
 990         self->Connect( func );
 991       }
 992 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
 993         self->Disconnect( func );
 994       }
 995 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,Dali::Actor arg1,Dali::TapGesture const &arg2){
 996         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 997 /*@SWIG@*/ self->Emit( arg1, arg2 );
 998       }
 999 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1000          return self->Empty();
1001       }
1002 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1003         return self->GetConnectionCount();
1004       }
1005 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1006           self->Connect( func );
1007       }
1008 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1009           self->Disconnect( func );
1010       }
1011 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1012           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1013 /*@SWIG@*/ self->Emit( arg );
1014       }
1015 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1016          return self->Empty();
1017       }
1018 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){
1019         return self->GetConnectionCount();
1020       }
1021 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)){
1022           return self->Connect( func );
1023       }
1024 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)){
1025           self->Disconnect( func );
1026       }
1027 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){
1028           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1029 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1030       }
1031
1032 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1033          return self->Empty();
1034       }
1035 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1036         return self->GetConnectionCount();
1037       }
1038 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1039           self->Connect( func );
1040       }
1041 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1042           self->Disconnect( func );
1043       }
1044 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1045           return self->Emit();
1046       }
1047
1048 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1049         std::vector< unsigned int >* pv = 0;
1050         if (capacity >= 0) {
1051           pv = new std::vector< unsigned int >();
1052           pv->reserve(capacity);
1053        } else {
1054           throw std::out_of_range("capacity");
1055        }
1056        return pv;
1057       }
1058 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1059         if (index>=0 && index<(int)self->size())
1060           return (*self)[index];
1061         else
1062           throw std::out_of_range("index");
1063       }
1064 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1065         if (index>=0 && index<(int)self->size())
1066           return (*self)[index];
1067         else
1068           throw std::out_of_range("index");
1069       }
1070 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1071         if (index>=0 && index<(int)self->size())
1072           (*self)[index] = val;
1073         else
1074           throw std::out_of_range("index");
1075       }
1076 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1077         self->insert(self->end(), values.begin(), values.end());
1078       }
1079 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1080         if (index < 0)
1081           throw std::out_of_range("index");
1082         if (count < 0)
1083           throw std::out_of_range("count");
1084         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1085           throw std::invalid_argument("invalid range");
1086         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1087       }
1088 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1089         if (index>=0 && index<(int)self->size()+1)
1090           self->insert(self->begin()+index, x);
1091         else
1092           throw std::out_of_range("index");
1093       }
1094 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1095         if (index>=0 && index<(int)self->size()+1)
1096           self->insert(self->begin()+index, values.begin(), values.end());
1097         else
1098           throw std::out_of_range("index");
1099       }
1100 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1101         if (index>=0 && index<(int)self->size())
1102           self->erase(self->begin() + index);
1103         else
1104           throw std::out_of_range("index");
1105       }
1106 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1107         if (index < 0)
1108           throw std::out_of_range("index");
1109         if (count < 0)
1110           throw std::out_of_range("count");
1111         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1112           throw std::invalid_argument("invalid range");
1113         self->erase(self->begin()+index, self->begin()+index+count);
1114       }
1115 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1116         if (count < 0)
1117           throw std::out_of_range("count");
1118         return new std::vector< unsigned int >(count, value);
1119       }
1120 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1121         std::reverse(self->begin(), self->end());
1122       }
1123 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1124         if (index < 0)
1125           throw std::out_of_range("index");
1126         if (count < 0)
1127           throw std::out_of_range("count");
1128         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1129           throw std::invalid_argument("invalid range");
1130         std::reverse(self->begin()+index, self->begin()+index+count);
1131       }
1132 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1133         if (index < 0)
1134           throw std::out_of_range("index");
1135         if (index+values.size() > self->size())
1136           throw std::out_of_range("index");
1137         std::copy(values.begin(), values.end(), self->begin()+index);
1138       }
1139 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1140         return std::find(self->begin(), self->end(), value) != self->end();
1141       }
1142 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1143         int index = -1;
1144         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1145         if (it != self->end())
1146           index = (int)(it - self->begin());
1147         return index;
1148       }
1149 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1150         int index = -1;
1151         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1152         if (rit != self->rend())
1153           index = (int)(self->rend() - 1 - rit);
1154         return index;
1155       }
1156 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1157         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1158         if (it != self->end()) {
1159           self->erase(it);
1160           return true;
1161         }
1162         return false;
1163       }
1164 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){
1165         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1166         if (capacity >= 0) {
1167           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1168           pv->reserve(capacity);
1169        } else {
1170           throw std::out_of_range("capacity");
1171        }
1172        return pv;
1173       }
1174 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){
1175         if (index>=0 && index<(int)self->size())
1176           return (*self)[index];
1177         else
1178           throw std::out_of_range("index");
1179       }
1180 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){
1181         if (index>=0 && index<(int)self->size())
1182           return (*self)[index];
1183         else
1184           throw std::out_of_range("index");
1185       }
1186 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){
1187         if (index>=0 && index<(int)self->size())
1188           (*self)[index] = val;
1189         else
1190           throw std::out_of_range("index");
1191       }
1192 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){
1193         self->insert(self->end(), values.begin(), values.end());
1194       }
1195 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){
1196         if (index < 0)
1197           throw std::out_of_range("index");
1198         if (count < 0)
1199           throw std::out_of_range("count");
1200         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1201           throw std::invalid_argument("invalid range");
1202         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1203       }
1204 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){
1205         if (index>=0 && index<(int)self->size()+1)
1206           self->insert(self->begin()+index, x);
1207         else
1208           throw std::out_of_range("index");
1209       }
1210 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){
1211         if (index>=0 && index<(int)self->size()+1)
1212           self->insert(self->begin()+index, values.begin(), values.end());
1213         else
1214           throw std::out_of_range("index");
1215       }
1216 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){
1217         if (index>=0 && index<(int)self->size())
1218           self->erase(self->begin() + index);
1219         else
1220           throw std::out_of_range("index");
1221       }
1222 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){
1223         if (index < 0)
1224           throw std::out_of_range("index");
1225         if (count < 0)
1226           throw std::out_of_range("count");
1227         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1228           throw std::invalid_argument("invalid range");
1229         self->erase(self->begin()+index, self->begin()+index+count);
1230       }
1231 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){
1232         if (count < 0)
1233           throw std::out_of_range("count");
1234         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1235       }
1236 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){
1237         std::reverse(self->begin(), self->end());
1238       }
1239 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){
1240         if (index < 0)
1241           throw std::out_of_range("index");
1242         if (count < 0)
1243           throw std::out_of_range("count");
1244         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1245           throw std::invalid_argument("invalid range");
1246         std::reverse(self->begin()+index, self->begin()+index+count);
1247       }
1248 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){
1249         if (index < 0)
1250           throw std::out_of_range("index");
1251         if (index+values.size() > self->size())
1252           throw std::out_of_range("index");
1253         std::copy(values.begin(), values.end(), self->begin()+index);
1254       }
1255 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1256         std::vector< Dali::Actor >* pv = 0;
1257         if (capacity >= 0) {
1258           pv = new std::vector< Dali::Actor >();
1259           pv->reserve(capacity);
1260        } else {
1261           throw std::out_of_range("capacity");
1262        }
1263        return pv;
1264       }
1265 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1266         if (index>=0 && index<(int)self->size())
1267           return (*self)[index];
1268         else
1269           throw std::out_of_range("index");
1270       }
1271 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1272         if (index>=0 && index<(int)self->size())
1273           return (*self)[index];
1274         else
1275           throw std::out_of_range("index");
1276       }
1277 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1278         if (index>=0 && index<(int)self->size())
1279           (*self)[index] = val;
1280         else
1281           throw std::out_of_range("index");
1282       }
1283 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1284         self->insert(self->end(), values.begin(), values.end());
1285       }
1286 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1287         if (index < 0)
1288           throw std::out_of_range("index");
1289         if (count < 0)
1290           throw std::out_of_range("count");
1291         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1292           throw std::invalid_argument("invalid range");
1293         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1294       }
1295 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1296         if (index>=0 && index<(int)self->size()+1)
1297           self->insert(self->begin()+index, x);
1298         else
1299           throw std::out_of_range("index");
1300       }
1301 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1302         if (index>=0 && index<(int)self->size()+1)
1303           self->insert(self->begin()+index, values.begin(), values.end());
1304         else
1305           throw std::out_of_range("index");
1306       }
1307 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1308         if (index>=0 && index<(int)self->size())
1309           self->erase(self->begin() + index);
1310         else
1311           throw std::out_of_range("index");
1312       }
1313 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1314         if (index < 0)
1315           throw std::out_of_range("index");
1316         if (count < 0)
1317           throw std::out_of_range("count");
1318         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1319           throw std::invalid_argument("invalid range");
1320         self->erase(self->begin()+index, self->begin()+index+count);
1321       }
1322 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1323         if (count < 0)
1324           throw std::out_of_range("count");
1325         return new std::vector< Dali::Actor >(count, value);
1326       }
1327 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1328         std::reverse(self->begin(), self->end());
1329       }
1330 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1331         if (index < 0)
1332           throw std::out_of_range("index");
1333         if (count < 0)
1334           throw std::out_of_range("count");
1335         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1336           throw std::invalid_argument("invalid range");
1337         std::reverse(self->begin()+index, self->begin()+index+count);
1338       }
1339 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1340         if (index < 0)
1341           throw std::out_of_range("index");
1342         if (index+values.size() > self->size())
1343           throw std::out_of_range("index");
1344         std::copy(values.begin(), values.end(), self->begin()+index);
1345       }
1346 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1347          return self->Empty();
1348       }
1349 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1350         return self->GetConnectionCount();
1351       }
1352 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 &)){
1353           self->Connect( func );
1354       }
1355 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 &)){
1356           self->Disconnect( func );
1357       }
1358 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){
1359           return self->Emit( arg );
1360       }
1361 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){
1362          return self->Empty();
1363       }
1364 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){
1365         return self->GetConnectionCount();
1366       }
1367 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)){
1368         self->Connect( func );
1369       }
1370 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)){
1371         self->Disconnect( func );
1372       }
1373 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){
1374         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1375 /*@SWIG@*/ self->Emit( arg1, arg2 );
1376       }
1377 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1378          return self->Empty();
1379       }
1380 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){
1381         return self->GetConnectionCount();
1382       }
1383 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)){
1384         self->Connect( func );
1385       }
1386 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)){
1387         self->Disconnect( func );
1388       }
1389 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){
1390         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1391 /*@SWIG@*/ self->Emit( arg1, arg2 );
1392       }
1393 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1394          return self->Empty();
1395       }
1396 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1397         return self->GetConnectionCount();
1398       }
1399 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)){
1400         self->Connect( func );
1401       }
1402 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)){
1403         self->Disconnect( func );
1404       }
1405 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){
1406         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1407 /*@SWIG@*/ self->Emit( arg1, arg2 );
1408       }
1409 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){
1410          return self->Empty();
1411       }
1412 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){
1413         return self->GetConnectionCount();
1414       }
1415 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)){
1416         self->Connect( func );
1417       }
1418 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)){
1419         self->Disconnect( func );
1420       }
1421 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){
1422         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1423 /*@SWIG@*/ self->Emit( arg1, arg2 );
1424       }
1425 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1426          return self->Empty();
1427       }
1428 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1429         return self->GetConnectionCount();
1430       }
1431 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)){
1432           self->Connect( func );
1433       }
1434 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)){
1435           self->Disconnect( func );
1436       }
1437 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1438           return self->Emit( arg );
1439       }
1440 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1441          return self->Empty();
1442       }
1443 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1444         return self->GetConnectionCount();
1445       }
1446 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)){
1447           self->Connect( func );
1448       }
1449 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)){
1450           self->Disconnect( func );
1451       }
1452 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1453           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1454 /*@SWIG@*/ self->Emit( arg );
1455       }
1456 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){
1457          return self->Empty();
1458       }
1459 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){
1460         return self->GetConnectionCount();
1461       }
1462 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)){
1463           return self->Connect( func );
1464       }
1465 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)){
1466           self->Disconnect( func );
1467       }
1468 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){
1469           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1470 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1471       }
1472 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1473          return self->Empty();
1474       }
1475 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1476         return self->GetConnectionCount();
1477       }
1478 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)){
1479           self->Connect( func );
1480       }
1481 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)){
1482           self->Disconnect( func );
1483       }
1484 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1485           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1486 /*@SWIG@*/ self->Emit( arg );
1487       }
1488 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){
1489          return self->Empty();
1490       }
1491 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){
1492         return self->GetConnectionCount();
1493       }
1494 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)){
1495           return self->Connect( func );
1496       }
1497 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)){
1498           self->Disconnect( func );
1499       }
1500 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){
1501           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1502 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1503       }
1504 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){
1505          return self->Empty();
1506       }
1507 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){
1508         return self->GetConnectionCount();
1509       }
1510 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 &)){
1511           self->Connect( func );
1512       }
1513 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 &)){
1514           self->Disconnect( func );
1515       }
1516 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){
1517           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1518 /*@SWIG@*/ self->Emit( arg );
1519       }
1520 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1521          return self->Empty();
1522       }
1523 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){
1524         return self->GetConnectionCount();
1525       }
1526 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 &)){
1527           self->Connect( func );
1528       }
1529 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 &)){
1530           self->Disconnect( func );
1531       }
1532 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){
1533           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1534 /*@SWIG@*/ self->Emit( arg );
1535       }
1536
1537
1538 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){
1539          return self->Empty();
1540       }
1541 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){
1542         return self->GetConnectionCount();
1543       }
1544 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 &)){
1545         self->Connect( func );
1546       }
1547 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 &)){
1548         self->Disconnect( func );
1549       }
1550 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){
1551         return self->Emit( arg1, arg2 );
1552       }
1553 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1554          return self->Empty();
1555       }
1556 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1557         return self->GetConnectionCount();
1558       }
1559 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)){
1560           self->Connect( func );
1561       }
1562 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)){
1563           self->Disconnect( func );
1564       }
1565 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1566           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1567 /*@SWIG@*/ self->Emit( arg );
1568       }
1569 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1570          return self->Empty();
1571       }
1572 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1573         return self->GetConnectionCount();
1574       }
1575 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 &)){
1576           self->Connect( func );
1577       }
1578 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 &)){
1579           self->Disconnect( func );
1580       }
1581 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){
1582           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1583 /*@SWIG@*/ self->Emit( arg );
1584       }
1585 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1586          return self->Empty();
1587       }
1588 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){
1589         return self->GetConnectionCount();
1590       }
1591 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)){
1592         self->Connect( func );
1593       }
1594 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)){
1595         self->Disconnect( func );
1596       }
1597 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){
1598         return self->Emit( arg1, arg2 );
1599       }
1600 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1601          return self->Empty();
1602       }
1603 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){
1604         return self->GetConnectionCount();
1605       }
1606 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)){
1607         self->Connect( func );
1608       }
1609 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)){
1610         self->Disconnect( func );
1611       }
1612 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){
1613         return self->Emit( arg1, arg2 );
1614       }
1615
1616
1617 /* ---------------------------------------------------
1618  * C++ director class methods
1619  * --------------------------------------------------- */
1620
1621 #include "dali_wrap.h"
1622
1623 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1624   swig_init_callbacks();
1625 }
1626
1627 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1628
1629 }
1630
1631
1632 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1633   int jdepth  ;
1634
1635   if (!swig_callbackOnStageConnection) {
1636     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1637     return;
1638   } else {
1639     jdepth = depth;
1640     swig_callbackOnStageConnection(jdepth);
1641   }
1642 }
1643
1644 void SwigDirector_ViewImpl::OnStageDisconnection() {
1645   if (!swig_callbackOnStageDisconnection) {
1646     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1647     return;
1648   } else {
1649     swig_callbackOnStageDisconnection();
1650   }
1651 }
1652
1653 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1654   void * jchild = 0 ;
1655
1656   if (!swig_callbackOnChildAdd) {
1657     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1658     return;
1659   } else {
1660     jchild = (Dali::Actor *) &child;
1661     swig_callbackOnChildAdd(jchild);
1662   }
1663 }
1664
1665 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1666   void * jchild = 0 ;
1667
1668   if (!swig_callbackOnChildRemove) {
1669     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1670     return;
1671   } else {
1672     jchild = (Dali::Actor *) &child;
1673     swig_callbackOnChildRemove(jchild);
1674   }
1675 }
1676
1677 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1678   int jindex  ;
1679   void * jpropertyValue  ;
1680
1681   if (!swig_callbackOnPropertySet) {
1682     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1683     return;
1684   } else {
1685     jindex = index;
1686     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1687     swig_callbackOnPropertySet(jindex, jpropertyValue);
1688   }
1689 }
1690
1691 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1692   void * jtargetSize = 0 ;
1693
1694   if (!swig_callbackOnSizeSet) {
1695     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1696     return;
1697   } else {
1698     jtargetSize = (Dali::Vector3 *) &targetSize;
1699     swig_callbackOnSizeSet(jtargetSize);
1700   }
1701 }
1702
1703 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1704   void * janimation = 0 ;
1705   void * jtargetSize = 0 ;
1706
1707   if (!swig_callbackOnSizeAnimation) {
1708     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1709     return;
1710   } else {
1711     janimation = (Dali::Animation *) &animation;
1712     jtargetSize = (Dali::Vector3 *) &targetSize;
1713     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1714   }
1715 }
1716
1717 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1718   bool c_result = SwigValueInit< bool >() ;
1719   unsigned int jresult = 0 ;
1720   void * jarg0 = 0 ;
1721
1722   if (!swig_callbackOnTouchEvent) {
1723     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1724   } else {
1725     jarg0 = (Dali::TouchEvent *) &event;
1726     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1727     c_result = jresult ? true : false;
1728   }
1729   return c_result;
1730 }
1731
1732 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1733   bool c_result = SwigValueInit< bool >() ;
1734   unsigned int jresult = 0 ;
1735   void * jarg0 = 0 ;
1736
1737   if (!swig_callbackOnHoverEvent) {
1738     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1739   } else {
1740     jarg0 = (Dali::HoverEvent *) &event;
1741     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1742     c_result = jresult ? true : false;
1743   }
1744   return c_result;
1745 }
1746
1747 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1748   bool c_result = SwigValueInit< bool >() ;
1749   unsigned int jresult = 0 ;
1750   void * jarg0 = 0 ;
1751
1752   if (!swig_callbackOnKeyEvent) {
1753     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1754   } else {
1755     jarg0 = (Dali::KeyEvent *) &event;
1756     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1757     c_result = jresult ? true : false;
1758   }
1759   return c_result;
1760 }
1761
1762 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1763   bool c_result = SwigValueInit< bool >() ;
1764   unsigned int jresult = 0 ;
1765   void * jarg0 = 0 ;
1766
1767   if (!swig_callbackOnWheelEvent) {
1768     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1769   } else {
1770     jarg0 = (Dali::WheelEvent *) &event;
1771     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1772     c_result = jresult ? true : false;
1773   }
1774   return c_result;
1775 }
1776
1777 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1778   void * jsize = 0 ;
1779   void * jcontainer = 0 ;
1780
1781   if (!swig_callbackOnRelayout) {
1782     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1783     return;
1784   } else {
1785     jsize = (Dali::Vector2 *) &size;
1786     jcontainer = (Dali::RelayoutContainer *) &container;
1787     swig_callbackOnRelayout(jsize, jcontainer);
1788   }
1789 }
1790
1791 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1792   int jpolicy  ;
1793   int jdimension  ;
1794
1795   if (!swig_callbackOnSetResizePolicy) {
1796     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1797     return;
1798   } else {
1799     jpolicy = (int)policy;
1800     jdimension = (int)dimension;
1801     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1802   }
1803 }
1804
1805 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1806   Dali::Vector3 c_result ;
1807   void * jresult = 0 ;
1808
1809   if (!swig_callbackGetNaturalSize) {
1810     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1811   } else {
1812     jresult = (void *) swig_callbackGetNaturalSize();
1813     if (!jresult) {
1814       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1815       return c_result;
1816     }
1817     c_result = *(Dali::Vector3 *)jresult;
1818   }
1819   return c_result;
1820 }
1821
1822 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
1823   float c_result = SwigValueInit< float >() ;
1824   float jresult = 0 ;
1825   void * jchild = 0 ;
1826   int jdimension  ;
1827
1828   if (!swig_callbackCalculateChildSize) {
1829     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
1830   } else {
1831     jchild = (Dali::Actor *) &child;
1832     jdimension = (int)dimension;
1833     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
1834     c_result = (float)jresult;
1835   }
1836   return c_result;
1837 }
1838
1839 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
1840   float c_result = SwigValueInit< float >() ;
1841   float jresult = 0 ;
1842   float jwidth  ;
1843
1844   if (!swig_callbackGetHeightForWidth) {
1845     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
1846   } else {
1847     jwidth = width;
1848     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
1849     c_result = (float)jresult;
1850   }
1851   return c_result;
1852 }
1853
1854 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
1855   float c_result = SwigValueInit< float >() ;
1856   float jresult = 0 ;
1857   float jheight  ;
1858
1859   if (!swig_callbackGetWidthForHeight) {
1860     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
1861   } else {
1862     jheight = height;
1863     jresult = (float) swig_callbackGetWidthForHeight(jheight);
1864     c_result = (float)jresult;
1865   }
1866   return c_result;
1867 }
1868
1869 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
1870   bool c_result = SwigValueInit< bool >() ;
1871   unsigned int jresult = 0 ;
1872   int jdimension  ;
1873
1874   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
1875     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
1876   } else {
1877     jdimension = (int)dimension;
1878     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
1879     c_result = jresult ? true : false;
1880   }
1881   return c_result;
1882 }
1883
1884 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
1885   int jdimension  ;
1886
1887   if (!swig_callbackOnCalculateRelayoutSize) {
1888     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
1889     return;
1890   } else {
1891     jdimension = (int)dimension;
1892     swig_callbackOnCalculateRelayoutSize(jdimension);
1893   }
1894 }
1895
1896 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
1897   float jsize  ;
1898   int jdimension  ;
1899
1900   if (!swig_callbackOnLayoutNegotiated) {
1901     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
1902     return;
1903   } else {
1904     jsize = size;
1905     jdimension = (int)dimension;
1906     swig_callbackOnLayoutNegotiated(jsize, jdimension);
1907   }
1908 }
1909
1910 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
1911   return Dali::CustomActorImpl::GetExtension();
1912 }
1913
1914 void SwigDirector_ViewImpl::OnInitialize() {
1915   if (!swig_callbackOnInitialize) {
1916     Dali::Toolkit::Internal::Control::OnInitialize();
1917     return;
1918   } else {
1919     swig_callbackOnInitialize();
1920   }
1921 }
1922
1923 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
1924   void * jchild = 0 ;
1925
1926   if (!swig_callbackOnControlChildAdd) {
1927     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
1928     return;
1929   } else {
1930     jchild = (Dali::Actor *) &child;
1931     swig_callbackOnControlChildAdd(jchild);
1932   }
1933 }
1934
1935 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
1936   void * jchild = 0 ;
1937
1938   if (!swig_callbackOnControlChildRemove) {
1939     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
1940     return;
1941   } else {
1942     jchild = (Dali::Actor *) &child;
1943     swig_callbackOnControlChildRemove(jchild);
1944   }
1945 }
1946
1947 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
1948   void * jstyleManager  ;
1949   int jchange  ;
1950
1951   if (!swig_callbackOnStyleChange) {
1952     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
1953     return;
1954   } else {
1955     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
1956     jchange = (int)change;
1957     swig_callbackOnStyleChange(jstyleManager, jchange);
1958   }
1959 }
1960
1961 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
1962   bool c_result = SwigValueInit< bool >() ;
1963   unsigned int jresult = 0 ;
1964
1965   if (!swig_callbackOnAccessibilityActivated) {
1966     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
1967   } else {
1968     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
1969     c_result = jresult ? true : false;
1970   }
1971   return c_result;
1972 }
1973
1974 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
1975   bool c_result = SwigValueInit< bool >() ;
1976   unsigned int jresult = 0 ;
1977   void * jgesture  ;
1978
1979   if (!swig_callbackOnAccessibilityPan) {
1980     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
1981   } else {
1982     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
1983     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
1984     c_result = jresult ? true : false;
1985   }
1986   return c_result;
1987 }
1988
1989 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
1990   bool c_result = SwigValueInit< bool >() ;
1991   unsigned int jresult = 0 ;
1992   void * jtouchEvent = 0 ;
1993
1994   if (!swig_callbackOnAccessibilityTouch) {
1995     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
1996   } else {
1997     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
1998     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
1999     c_result = jresult ? true : false;
2000   }
2001   return c_result;
2002 }
2003
2004 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2005   bool c_result = SwigValueInit< bool >() ;
2006   unsigned int jresult = 0 ;
2007   unsigned int jisIncrease  ;
2008
2009   if (!swig_callbackOnAccessibilityValueChange) {
2010     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2011   } else {
2012     jisIncrease = isIncrease;
2013     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2014     c_result = jresult ? true : false;
2015   }
2016   return c_result;
2017 }
2018
2019 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2020   bool c_result = SwigValueInit< bool >() ;
2021   unsigned int jresult = 0 ;
2022
2023   if (!swig_callbackOnAccessibilityZoom) {
2024     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2025   } else {
2026     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2027     c_result = jresult ? true : false;
2028   }
2029   return c_result;
2030 }
2031
2032 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2033   if (!swig_callbackOnKeyInputFocusGained) {
2034     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2035     return;
2036   } else {
2037     swig_callbackOnKeyInputFocusGained();
2038   }
2039 }
2040
2041 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2042   if (!swig_callbackOnKeyInputFocusLost) {
2043     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2044     return;
2045   } else {
2046     swig_callbackOnKeyInputFocusLost();
2047   }
2048 }
2049
2050 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2051   Dali::Actor c_result ;
2052   void * jresult = 0 ;
2053   void * jcurrentFocusedActor  ;
2054   int jdirection  ;
2055   unsigned int jloopEnabled  ;
2056
2057   if (!swig_callbackGetNextKeyboardFocusableActor) {
2058     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2059   } else {
2060     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2061     jdirection = (int)direction;
2062     jloopEnabled = loopEnabled;
2063     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2064     if (!jresult) {
2065       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2066       return c_result;
2067     }
2068     c_result = *(Dali::Actor *)jresult;
2069   }
2070   return c_result;
2071 }
2072
2073 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2074   void * jcommitedFocusableActor  ;
2075
2076   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2077     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2078     return;
2079   } else {
2080     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2081     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2082   }
2083 }
2084
2085 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2086   bool c_result = SwigValueInit< bool >() ;
2087   unsigned int jresult = 0 ;
2088
2089   if (!swig_callbackOnKeyboardEnter) {
2090     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2091   } else {
2092     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2093     c_result = jresult ? true : false;
2094   }
2095   return c_result;
2096 }
2097
2098 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2099   void * jpinch = 0 ;
2100
2101   if (!swig_callbackOnPinch) {
2102     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2103     return;
2104   } else {
2105     jpinch = (Dali::PinchGesture *) &pinch;
2106     swig_callbackOnPinch(jpinch);
2107   }
2108 }
2109
2110 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2111   void * jpan = 0 ;
2112
2113   if (!swig_callbackOnPan) {
2114     Dali::Toolkit::Internal::Control::OnPan(pan);
2115     return;
2116   } else {
2117     jpan = (Dali::PanGesture *) &pan;
2118     swig_callbackOnPan(jpan);
2119   }
2120 }
2121
2122 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2123   void * jtap = 0 ;
2124
2125   if (!swig_callbackOnTap) {
2126     Dali::Toolkit::Internal::Control::OnTap(tap);
2127     return;
2128   } else {
2129     jtap = (Dali::TapGesture *) &tap;
2130     swig_callbackOnTap(jtap);
2131   }
2132 }
2133
2134 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2135   void * jlongPress = 0 ;
2136
2137   if (!swig_callbackOnLongPress) {
2138     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2139     return;
2140   } else {
2141     jlongPress = (Dali::LongPressGesture *) &longPress;
2142     swig_callbackOnLongPress(jlongPress);
2143   }
2144 }
2145
2146 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2147   void * jslotObserver = 0 ;
2148   void * jcallback = 0 ;
2149
2150   if (!swig_callbackSignalConnected) {
2151     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2152     return;
2153   } else {
2154     jslotObserver = (void *) slotObserver;
2155     jcallback = (void *) callback;
2156     swig_callbackSignalConnected(jslotObserver, jcallback);
2157   }
2158 }
2159
2160 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2161   void * jslotObserver = 0 ;
2162   void * jcallback = 0 ;
2163
2164   if (!swig_callbackSignalDisconnected) {
2165     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2166     return;
2167   } else {
2168     jslotObserver = (void *) slotObserver;
2169     jcallback = (void *) callback;
2170     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2171   }
2172 }
2173
2174 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2175   return Dali::Toolkit::Internal::Control::GetControlExtension();
2176 }
2177
2178 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) {
2179   swig_callbackOnStageConnection = callbackOnStageConnection;
2180   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2181   swig_callbackOnChildAdd = callbackOnChildAdd;
2182   swig_callbackOnChildRemove = callbackOnChildRemove;
2183   swig_callbackOnPropertySet = callbackOnPropertySet;
2184   swig_callbackOnSizeSet = callbackOnSizeSet;
2185   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2186   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2187   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2188   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2189   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2190   swig_callbackOnRelayout = callbackOnRelayout;
2191   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2192   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2193   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2194   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2195   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2196   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2197   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2198   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2199   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2200   swig_callbackOnInitialize = callbackOnInitialize;
2201   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2202   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2203   swig_callbackOnStyleChange = callbackOnStyleChange;
2204   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2205   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2206   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2207   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2208   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2209   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2210   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2211   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2212   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2213   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2214   swig_callbackOnPinch = callbackOnPinch;
2215   swig_callbackOnPan = callbackOnPan;
2216   swig_callbackOnTap = callbackOnTap;
2217   swig_callbackOnLongPress = callbackOnLongPress;
2218   swig_callbackSignalConnected = callbackSignalConnected;
2219   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2220 }
2221
2222 void SwigDirector_ViewImpl::swig_init_callbacks() {
2223   swig_callbackOnStageConnection = 0;
2224   swig_callbackOnStageDisconnection = 0;
2225   swig_callbackOnChildAdd = 0;
2226   swig_callbackOnChildRemove = 0;
2227   swig_callbackOnPropertySet = 0;
2228   swig_callbackOnSizeSet = 0;
2229   swig_callbackOnSizeAnimation = 0;
2230   swig_callbackOnTouchEvent = 0;
2231   swig_callbackOnHoverEvent = 0;
2232   swig_callbackOnKeyEvent = 0;
2233   swig_callbackOnWheelEvent = 0;
2234   swig_callbackOnRelayout = 0;
2235   swig_callbackOnSetResizePolicy = 0;
2236   swig_callbackGetNaturalSize = 0;
2237   swig_callbackCalculateChildSize = 0;
2238   swig_callbackGetHeightForWidth = 0;
2239   swig_callbackGetWidthForHeight = 0;
2240   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2241   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2242   swig_callbackOnCalculateRelayoutSize = 0;
2243   swig_callbackOnLayoutNegotiated = 0;
2244   swig_callbackOnInitialize = 0;
2245   swig_callbackOnControlChildAdd = 0;
2246   swig_callbackOnControlChildRemove = 0;
2247   swig_callbackOnStyleChange = 0;
2248   swig_callbackOnAccessibilityActivated = 0;
2249   swig_callbackOnAccessibilityPan = 0;
2250   swig_callbackOnAccessibilityTouch = 0;
2251   swig_callbackOnAccessibilityValueChange = 0;
2252   swig_callbackOnAccessibilityZoom = 0;
2253   swig_callbackOnKeyInputFocusGained = 0;
2254   swig_callbackOnKeyInputFocusLost = 0;
2255   swig_callbackGetNextKeyboardFocusableActor = 0;
2256   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2257   swig_callbackOnKeyboardEnter = 0;
2258   swig_callbackOnPinch = 0;
2259   swig_callbackOnPan = 0;
2260   swig_callbackOnTap = 0;
2261   swig_callbackOnLongPress = 0;
2262   swig_callbackSignalConnected = 0;
2263   swig_callbackSignalDisconnected = 0;
2264 }
2265
2266 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2267   swig_init_callbacks();
2268 }
2269
2270 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2271
2272 }
2273
2274
2275 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2276   unsigned int c_result = SwigValueInit< unsigned int >() ;
2277   unsigned int jresult = 0 ;
2278
2279   if (!swig_callbackGetNumberOfItems) {
2280     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2281   } else {
2282     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2283     c_result = (unsigned int)jresult;
2284   }
2285   return c_result;
2286 }
2287
2288 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2289   Dali::Actor c_result ;
2290   void * jresult = 0 ;
2291   unsigned int jitemId  ;
2292
2293   if (!swig_callbackNewItem) {
2294     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2295   } else {
2296     jitemId = itemId;
2297     jresult = (void *) swig_callbackNewItem(jitemId);
2298     if (!jresult) {
2299       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2300       return c_result;
2301     }
2302     c_result = *(Dali::Actor *)jresult;
2303   }
2304   return c_result;
2305 }
2306
2307 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2308   unsigned int jitemId  ;
2309   void * jactor  ;
2310
2311   if (!swig_callbackItemReleased) {
2312     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2313     return;
2314   } else {
2315     jitemId = itemId;
2316     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2317     swig_callbackItemReleased(jitemId, jactor);
2318   }
2319 }
2320
2321 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2322   return Dali::Toolkit::ItemFactory::GetExtension();
2323 }
2324
2325 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2326   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2327   swig_callbackNewItem = callbackNewItem;
2328   swig_callbackItemReleased = callbackItemReleased;
2329 }
2330
2331 void SwigDirector_ItemFactory::swig_init_callbacks() {
2332   swig_callbackGetNumberOfItems = 0;
2333   swig_callbackNewItem = 0;
2334   swig_callbackItemReleased = 0;
2335 }
2336
2337 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2338   swig_init_callbacks();
2339 }
2340
2341 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2342
2343 }
2344
2345
2346 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2347   Dali::Actor c_result ;
2348   void * jresult = 0 ;
2349   void * jcurrent  ;
2350   void * jproposed  ;
2351   int jdirection  ;
2352
2353   if (!swig_callbackGetNextFocusableActor) {
2354     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2355   } else {
2356     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2357     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2358     jdirection = (int)direction;
2359     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2360     if (!jresult) {
2361       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2362       return c_result;
2363     }
2364     c_result = *(Dali::Actor *)jresult;
2365   }
2366   return c_result;
2367 }
2368
2369 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2370   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2371 }
2372
2373 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2374   swig_callbackGetNextFocusableActor = 0;
2375 }
2376
2377
2378 #ifdef __cplusplus
2379 extern "C" {
2380 #endif
2381
2382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2383   void * jresult ;
2384   floatp *result = 0 ;
2385
2386   {
2387     try {
2388       result = (floatp *)new_floatp();
2389     } catch (std::out_of_range& e) {
2390       {
2391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2392       };
2393     } catch (std::exception& e) {
2394       {
2395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2396       };
2397     } catch (...) {
2398       {
2399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2400       };
2401     }
2402   }
2403   jresult = (void *)result;
2404   return jresult;
2405 }
2406
2407
2408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2409   floatp *arg1 = (floatp *) 0 ;
2410
2411   arg1 = (floatp *)jarg1;
2412   {
2413     try {
2414       delete_floatp(arg1);
2415     } catch (std::out_of_range& e) {
2416       {
2417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2418       };
2419     } catch (std::exception& e) {
2420       {
2421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2422       };
2423     } catch (...) {
2424       {
2425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2426       };
2427     }
2428   }
2429 }
2430
2431
2432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2433   floatp *arg1 = (floatp *) 0 ;
2434   float arg2 ;
2435
2436   arg1 = (floatp *)jarg1;
2437   arg2 = (float)jarg2;
2438   {
2439     try {
2440       floatp_assign(arg1,arg2);
2441     } catch (std::out_of_range& e) {
2442       {
2443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2444       };
2445     } catch (std::exception& e) {
2446       {
2447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2448       };
2449     } catch (...) {
2450       {
2451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2452       };
2453     }
2454   }
2455 }
2456
2457
2458 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2459   float jresult ;
2460   floatp *arg1 = (floatp *) 0 ;
2461   float result;
2462
2463   arg1 = (floatp *)jarg1;
2464   {
2465     try {
2466       result = (float)floatp_value(arg1);
2467     } catch (std::out_of_range& e) {
2468       {
2469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2470       };
2471     } catch (std::exception& e) {
2472       {
2473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2474       };
2475     } catch (...) {
2476       {
2477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2478       };
2479     }
2480   }
2481   jresult = result;
2482   return jresult;
2483 }
2484
2485
2486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2487   void * jresult ;
2488   floatp *arg1 = (floatp *) 0 ;
2489   float *result = 0 ;
2490
2491   arg1 = (floatp *)jarg1;
2492   {
2493     try {
2494       result = (float *)floatp_cast(arg1);
2495     } catch (std::out_of_range& e) {
2496       {
2497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2498       };
2499     } catch (std::exception& e) {
2500       {
2501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2502       };
2503     } catch (...) {
2504       {
2505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2506       };
2507     }
2508   }
2509   jresult = (void *)result;
2510   return jresult;
2511 }
2512
2513
2514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2515   void * jresult ;
2516   float *arg1 = (float *) 0 ;
2517   floatp *result = 0 ;
2518
2519   arg1 = (float *)jarg1;
2520   {
2521     try {
2522       result = (floatp *)floatp_frompointer(arg1);
2523     } catch (std::out_of_range& e) {
2524       {
2525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2526       };
2527     } catch (std::exception& e) {
2528       {
2529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2530       };
2531     } catch (...) {
2532       {
2533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2534       };
2535     }
2536   }
2537   jresult = (void *)result;
2538   return jresult;
2539 }
2540
2541
2542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2543   void * jresult ;
2544   intp *result = 0 ;
2545
2546   {
2547     try {
2548       result = (intp *)new_intp();
2549     } catch (std::out_of_range& e) {
2550       {
2551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2552       };
2553     } catch (std::exception& e) {
2554       {
2555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2556       };
2557     } catch (...) {
2558       {
2559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2560       };
2561     }
2562   }
2563   jresult = (void *)result;
2564   return jresult;
2565 }
2566
2567
2568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2569   intp *arg1 = (intp *) 0 ;
2570
2571   arg1 = (intp *)jarg1;
2572   {
2573     try {
2574       delete_intp(arg1);
2575     } catch (std::out_of_range& e) {
2576       {
2577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2578       };
2579     } catch (std::exception& e) {
2580       {
2581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2582       };
2583     } catch (...) {
2584       {
2585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2586       };
2587     }
2588   }
2589 }
2590
2591
2592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2593   intp *arg1 = (intp *) 0 ;
2594   int arg2 ;
2595
2596   arg1 = (intp *)jarg1;
2597   arg2 = (int)jarg2;
2598   {
2599     try {
2600       intp_assign(arg1,arg2);
2601     } catch (std::out_of_range& e) {
2602       {
2603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2604       };
2605     } catch (std::exception& e) {
2606       {
2607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2608       };
2609     } catch (...) {
2610       {
2611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2612       };
2613     }
2614   }
2615 }
2616
2617
2618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2619   int jresult ;
2620   intp *arg1 = (intp *) 0 ;
2621   int result;
2622
2623   arg1 = (intp *)jarg1;
2624   {
2625     try {
2626       result = (int)intp_value(arg1);
2627     } catch (std::out_of_range& e) {
2628       {
2629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2630       };
2631     } catch (std::exception& e) {
2632       {
2633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2634       };
2635     } catch (...) {
2636       {
2637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2638       };
2639     }
2640   }
2641   jresult = result;
2642   return jresult;
2643 }
2644
2645
2646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2647   void * jresult ;
2648   intp *arg1 = (intp *) 0 ;
2649   int *result = 0 ;
2650
2651   arg1 = (intp *)jarg1;
2652   {
2653     try {
2654       result = (int *)intp_cast(arg1);
2655     } catch (std::out_of_range& e) {
2656       {
2657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2658       };
2659     } catch (std::exception& e) {
2660       {
2661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2662       };
2663     } catch (...) {
2664       {
2665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2666       };
2667     }
2668   }
2669   jresult = (void *)result;
2670   return jresult;
2671 }
2672
2673
2674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2675   void * jresult ;
2676   int *arg1 = (int *) 0 ;
2677   intp *result = 0 ;
2678
2679   arg1 = (int *)jarg1;
2680   {
2681     try {
2682       result = (intp *)intp_frompointer(arg1);
2683     } catch (std::out_of_range& e) {
2684       {
2685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2686       };
2687     } catch (std::exception& e) {
2688       {
2689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2690       };
2691     } catch (...) {
2692       {
2693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2694       };
2695     }
2696   }
2697   jresult = (void *)result;
2698   return jresult;
2699 }
2700
2701
2702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2703   void * jresult ;
2704   doublep *result = 0 ;
2705
2706   {
2707     try {
2708       result = (doublep *)new_doublep();
2709     } catch (std::out_of_range& e) {
2710       {
2711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2712       };
2713     } catch (std::exception& e) {
2714       {
2715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2716       };
2717     } catch (...) {
2718       {
2719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2720       };
2721     }
2722   }
2723   jresult = (void *)result;
2724   return jresult;
2725 }
2726
2727
2728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2729   doublep *arg1 = (doublep *) 0 ;
2730
2731   arg1 = (doublep *)jarg1;
2732   {
2733     try {
2734       delete_doublep(arg1);
2735     } catch (std::out_of_range& e) {
2736       {
2737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2738       };
2739     } catch (std::exception& e) {
2740       {
2741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2742       };
2743     } catch (...) {
2744       {
2745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2746       };
2747     }
2748   }
2749 }
2750
2751
2752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2753   doublep *arg1 = (doublep *) 0 ;
2754   double arg2 ;
2755
2756   arg1 = (doublep *)jarg1;
2757   arg2 = (double)jarg2;
2758   {
2759     try {
2760       doublep_assign(arg1,arg2);
2761     } catch (std::out_of_range& e) {
2762       {
2763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2764       };
2765     } catch (std::exception& e) {
2766       {
2767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2768       };
2769     } catch (...) {
2770       {
2771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2772       };
2773     }
2774   }
2775 }
2776
2777
2778 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
2779   double jresult ;
2780   doublep *arg1 = (doublep *) 0 ;
2781   double result;
2782
2783   arg1 = (doublep *)jarg1;
2784   {
2785     try {
2786       result = (double)doublep_value(arg1);
2787     } catch (std::out_of_range& e) {
2788       {
2789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2790       };
2791     } catch (std::exception& e) {
2792       {
2793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2794       };
2795     } catch (...) {
2796       {
2797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2798       };
2799     }
2800   }
2801   jresult = result;
2802   return jresult;
2803 }
2804
2805
2806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
2807   void * jresult ;
2808   doublep *arg1 = (doublep *) 0 ;
2809   double *result = 0 ;
2810
2811   arg1 = (doublep *)jarg1;
2812   {
2813     try {
2814       result = (double *)doublep_cast(arg1);
2815     } catch (std::out_of_range& e) {
2816       {
2817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2818       };
2819     } catch (std::exception& e) {
2820       {
2821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2822       };
2823     } catch (...) {
2824       {
2825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2826       };
2827     }
2828   }
2829   jresult = (void *)result;
2830   return jresult;
2831 }
2832
2833
2834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
2835   void * jresult ;
2836   double *arg1 = (double *) 0 ;
2837   doublep *result = 0 ;
2838
2839   arg1 = (double *)jarg1;
2840   {
2841     try {
2842       result = (doublep *)doublep_frompointer(arg1);
2843     } catch (std::out_of_range& e) {
2844       {
2845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2846       };
2847     } catch (std::exception& e) {
2848       {
2849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2850       };
2851     } catch (...) {
2852       {
2853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2854       };
2855     }
2856   }
2857   jresult = (void *)result;
2858   return jresult;
2859 }
2860
2861
2862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
2863   void * jresult ;
2864   uintp *result = 0 ;
2865
2866   {
2867     try {
2868       result = (uintp *)new_uintp();
2869     } catch (std::out_of_range& e) {
2870       {
2871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2872       };
2873     } catch (std::exception& e) {
2874       {
2875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2876       };
2877     } catch (...) {
2878       {
2879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2880       };
2881     }
2882   }
2883   jresult = (void *)result;
2884   return jresult;
2885 }
2886
2887
2888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
2889   uintp *arg1 = (uintp *) 0 ;
2890
2891   arg1 = (uintp *)jarg1;
2892   {
2893     try {
2894       delete_uintp(arg1);
2895     } catch (std::out_of_range& e) {
2896       {
2897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2898       };
2899     } catch (std::exception& e) {
2900       {
2901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2902       };
2903     } catch (...) {
2904       {
2905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2906       };
2907     }
2908   }
2909 }
2910
2911
2912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
2913   uintp *arg1 = (uintp *) 0 ;
2914   unsigned int arg2 ;
2915
2916   arg1 = (uintp *)jarg1;
2917   arg2 = (unsigned int)jarg2;
2918   {
2919     try {
2920       uintp_assign(arg1,arg2);
2921     } catch (std::out_of_range& e) {
2922       {
2923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2924       };
2925     } catch (std::exception& e) {
2926       {
2927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2928       };
2929     } catch (...) {
2930       {
2931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2932       };
2933     }
2934   }
2935 }
2936
2937
2938 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
2939   unsigned int jresult ;
2940   uintp *arg1 = (uintp *) 0 ;
2941   unsigned int result;
2942
2943   arg1 = (uintp *)jarg1;
2944   {
2945     try {
2946       result = (unsigned int)uintp_value(arg1);
2947     } catch (std::out_of_range& e) {
2948       {
2949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2950       };
2951     } catch (std::exception& e) {
2952       {
2953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2954       };
2955     } catch (...) {
2956       {
2957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2958       };
2959     }
2960   }
2961   jresult = result;
2962   return jresult;
2963 }
2964
2965
2966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
2967   void * jresult ;
2968   uintp *arg1 = (uintp *) 0 ;
2969   unsigned int *result = 0 ;
2970
2971   arg1 = (uintp *)jarg1;
2972   {
2973     try {
2974       result = (unsigned int *)uintp_cast(arg1);
2975     } catch (std::out_of_range& e) {
2976       {
2977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2978       };
2979     } catch (std::exception& e) {
2980       {
2981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2982       };
2983     } catch (...) {
2984       {
2985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2986       };
2987     }
2988   }
2989   jresult = (void *)result;
2990   return jresult;
2991 }
2992
2993
2994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
2995   void * jresult ;
2996   unsigned int *arg1 = (unsigned int *) 0 ;
2997   uintp *result = 0 ;
2998
2999   arg1 = (unsigned int *)jarg1;
3000   {
3001     try {
3002       result = (uintp *)uintp_frompointer(arg1);
3003     } catch (std::out_of_range& e) {
3004       {
3005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3006       };
3007     } catch (std::exception& e) {
3008       {
3009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3010       };
3011     } catch (...) {
3012       {
3013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3014       };
3015     }
3016   }
3017   jresult = (void *)result;
3018   return jresult;
3019 }
3020
3021
3022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3023   void * jresult ;
3024   ushortp *result = 0 ;
3025
3026   {
3027     try {
3028       result = (ushortp *)new_ushortp();
3029     } catch (std::out_of_range& e) {
3030       {
3031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3032       };
3033     } catch (std::exception& e) {
3034       {
3035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3036       };
3037     } catch (...) {
3038       {
3039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3040       };
3041     }
3042   }
3043   jresult = (void *)result;
3044   return jresult;
3045 }
3046
3047
3048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3049   ushortp *arg1 = (ushortp *) 0 ;
3050
3051   arg1 = (ushortp *)jarg1;
3052   {
3053     try {
3054       delete_ushortp(arg1);
3055     } catch (std::out_of_range& e) {
3056       {
3057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3058       };
3059     } catch (std::exception& e) {
3060       {
3061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3062       };
3063     } catch (...) {
3064       {
3065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3066       };
3067     }
3068   }
3069 }
3070
3071
3072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3073   ushortp *arg1 = (ushortp *) 0 ;
3074   unsigned short arg2 ;
3075
3076   arg1 = (ushortp *)jarg1;
3077   arg2 = (unsigned short)jarg2;
3078   {
3079     try {
3080       ushortp_assign(arg1,arg2);
3081     } catch (std::out_of_range& e) {
3082       {
3083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3084       };
3085     } catch (std::exception& e) {
3086       {
3087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3088       };
3089     } catch (...) {
3090       {
3091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3092       };
3093     }
3094   }
3095 }
3096
3097
3098 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3099   unsigned short jresult ;
3100   ushortp *arg1 = (ushortp *) 0 ;
3101   unsigned short result;
3102
3103   arg1 = (ushortp *)jarg1;
3104   {
3105     try {
3106       result = (unsigned short)ushortp_value(arg1);
3107     } catch (std::out_of_range& e) {
3108       {
3109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3110       };
3111     } catch (std::exception& e) {
3112       {
3113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3114       };
3115     } catch (...) {
3116       {
3117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3118       };
3119     }
3120   }
3121   jresult = result;
3122   return jresult;
3123 }
3124
3125
3126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3127   void * jresult ;
3128   ushortp *arg1 = (ushortp *) 0 ;
3129   unsigned short *result = 0 ;
3130
3131   arg1 = (ushortp *)jarg1;
3132   {
3133     try {
3134       result = (unsigned short *)ushortp_cast(arg1);
3135     } catch (std::out_of_range& e) {
3136       {
3137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3138       };
3139     } catch (std::exception& e) {
3140       {
3141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3142       };
3143     } catch (...) {
3144       {
3145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3146       };
3147     }
3148   }
3149   jresult = (void *)result;
3150   return jresult;
3151 }
3152
3153
3154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3155   void * jresult ;
3156   unsigned short *arg1 = (unsigned short *) 0 ;
3157   ushortp *result = 0 ;
3158
3159   arg1 = (unsigned short *)jarg1;
3160   {
3161     try {
3162       result = (ushortp *)ushortp_frompointer(arg1);
3163     } catch (std::out_of_range& e) {
3164       {
3165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3166       };
3167     } catch (std::exception& e) {
3168       {
3169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3170       };
3171     } catch (...) {
3172       {
3173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3174       };
3175     }
3176   }
3177   jresult = (void *)result;
3178   return jresult;
3179 }
3180
3181
3182 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3183   unsigned int jresult ;
3184   int arg1 ;
3185   unsigned int result;
3186
3187   arg1 = (int)jarg1;
3188   {
3189     try {
3190       result = (unsigned int)int_to_uint(arg1);
3191     } catch (std::out_of_range& e) {
3192       {
3193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3194       };
3195     } catch (std::exception& e) {
3196       {
3197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3198       };
3199     } catch (...) {
3200       {
3201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3202       };
3203     }
3204   }
3205   jresult = result;
3206   return jresult;
3207 }
3208
3209
3210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3211   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3212
3213   arg1 = (Dali::RefObject *)jarg1;
3214   {
3215     try {
3216       (arg1)->Reference();
3217     } catch (std::out_of_range& e) {
3218       {
3219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3220       };
3221     } catch (std::exception& e) {
3222       {
3223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3224       };
3225     } catch (...) {
3226       {
3227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3228       };
3229     }
3230   }
3231 }
3232
3233
3234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3235   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3236
3237   arg1 = (Dali::RefObject *)jarg1;
3238   {
3239     try {
3240       (arg1)->Unreference();
3241     } catch (std::out_of_range& e) {
3242       {
3243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3244       };
3245     } catch (std::exception& e) {
3246       {
3247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3248       };
3249     } catch (...) {
3250       {
3251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3252       };
3253     }
3254   }
3255 }
3256
3257
3258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3259   int jresult ;
3260   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3261   int result;
3262
3263   arg1 = (Dali::RefObject *)jarg1;
3264   {
3265     try {
3266       result = (int)(arg1)->ReferenceCount();
3267     } catch (std::out_of_range& e) {
3268       {
3269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3270       };
3271     } catch (std::exception& e) {
3272       {
3273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3274       };
3275     } catch (...) {
3276       {
3277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3278       };
3279     }
3280   }
3281   jresult = result;
3282   return jresult;
3283 }
3284
3285
3286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3287   void * jresult ;
3288   Dali::Any *result = 0 ;
3289
3290   {
3291     try {
3292       result = (Dali::Any *)new Dali::Any();
3293     } catch (std::out_of_range& e) {
3294       {
3295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3296       };
3297     } catch (std::exception& e) {
3298       {
3299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3300       };
3301     } catch (...) {
3302       {
3303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3304       };
3305     }
3306   }
3307   jresult = (void *)result;
3308   return jresult;
3309 }
3310
3311
3312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3313   Dali::Any *arg1 = (Dali::Any *) 0 ;
3314
3315   arg1 = (Dali::Any *)jarg1;
3316   {
3317     try {
3318       delete arg1;
3319     } catch (std::out_of_range& e) {
3320       {
3321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3322       };
3323     } catch (std::exception& e) {
3324       {
3325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3326       };
3327     } catch (...) {
3328       {
3329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3330       };
3331     }
3332   }
3333 }
3334
3335
3336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3337   char *arg1 = (char *) 0 ;
3338
3339   arg1 = (char *)jarg1;
3340   {
3341     try {
3342       Dali::Any::AssertAlways((char const *)arg1);
3343     } catch (std::out_of_range& e) {
3344       {
3345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3346       };
3347     } catch (std::exception& e) {
3348       {
3349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3350       };
3351     } catch (...) {
3352       {
3353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3354       };
3355     }
3356   }
3357 }
3358
3359
3360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3361   void * jresult ;
3362   Dali::Any *arg1 = 0 ;
3363   Dali::Any *result = 0 ;
3364
3365   arg1 = (Dali::Any *)jarg1;
3366   if (!arg1) {
3367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3368     return 0;
3369   }
3370   {
3371     try {
3372       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3373     } catch (std::out_of_range& e) {
3374       {
3375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3376       };
3377     } catch (std::exception& e) {
3378       {
3379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3380       };
3381     } catch (...) {
3382       {
3383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3384       };
3385     }
3386   }
3387   jresult = (void *)result;
3388   return jresult;
3389 }
3390
3391
3392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3393   void * jresult ;
3394   Dali::Any *arg1 = (Dali::Any *) 0 ;
3395   Dali::Any *arg2 = 0 ;
3396   Dali::Any *result = 0 ;
3397
3398   arg1 = (Dali::Any *)jarg1;
3399   arg2 = (Dali::Any *)jarg2;
3400   if (!arg2) {
3401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3402     return 0;
3403   }
3404   {
3405     try {
3406       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3407     } catch (std::out_of_range& e) {
3408       {
3409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3410       };
3411     } catch (std::exception& e) {
3412       {
3413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3414       };
3415     } catch (...) {
3416       {
3417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3418       };
3419     }
3420   }
3421   jresult = (void *)result;
3422   return jresult;
3423 }
3424
3425
3426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3427   void * jresult ;
3428   Dali::Any *arg1 = (Dali::Any *) 0 ;
3429   std::type_info *result = 0 ;
3430
3431   arg1 = (Dali::Any *)jarg1;
3432   {
3433     try {
3434       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3435     } catch (std::out_of_range& e) {
3436       {
3437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3438       };
3439     } catch (std::exception& e) {
3440       {
3441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3442       };
3443     } catch (...) {
3444       {
3445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3446       };
3447     }
3448   }
3449   jresult = (void *)result;
3450   return jresult;
3451 }
3452
3453
3454 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3455   unsigned int jresult ;
3456   Dali::Any *arg1 = (Dali::Any *) 0 ;
3457   bool result;
3458
3459   arg1 = (Dali::Any *)jarg1;
3460   {
3461     try {
3462       result = (bool)((Dali::Any const *)arg1)->Empty();
3463     } catch (std::out_of_range& e) {
3464       {
3465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3466       };
3467     } catch (std::exception& e) {
3468       {
3469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3470       };
3471     } catch (...) {
3472       {
3473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3474       };
3475     }
3476   }
3477   jresult = result;
3478   return jresult;
3479 }
3480
3481
3482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3483   void * jresult ;
3484   std::type_info *arg1 = 0 ;
3485   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3486   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3487   Dali::Any::AnyContainerBase *result = 0 ;
3488
3489   arg1 = (std::type_info *)jarg1;
3490   if (!arg1) {
3491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3492     return 0;
3493   }
3494   arg2 = (Dali::Any::CloneFunc)jarg2;
3495   arg3 = (Dali::Any::DeleteFunc)jarg3;
3496   {
3497     try {
3498       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3499     } catch (std::out_of_range& e) {
3500       {
3501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3502       };
3503     } catch (std::exception& e) {
3504       {
3505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3506       };
3507     } catch (...) {
3508       {
3509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3510       };
3511     }
3512   }
3513   jresult = (void *)result;
3514   return jresult;
3515 }
3516
3517
3518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3519   void * jresult ;
3520   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3521   std::type_info *result = 0 ;
3522
3523   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3524   {
3525     try {
3526       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3527     } catch (std::out_of_range& e) {
3528       {
3529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3530       };
3531     } catch (std::exception& e) {
3532       {
3533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3534       };
3535     } catch (...) {
3536       {
3537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3538       };
3539     }
3540   }
3541   jresult = (void *)result;
3542   return jresult;
3543 }
3544
3545
3546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3547   void * jresult ;
3548   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3549   ::std::type_info *result = 0 ;
3550
3551   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3552   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3553   jresult = (void *)result;
3554   return jresult;
3555 }
3556
3557
3558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3559   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3560   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3561
3562   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3563   arg2 = (Dali::Any::CloneFunc)jarg2;
3564   if (arg1) (arg1)->mCloneFunc = arg2;
3565 }
3566
3567
3568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3569   void * jresult ;
3570   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3571   Dali::Any::CloneFunc result;
3572
3573   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3574   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3575   jresult = (void *)result;
3576   return jresult;
3577 }
3578
3579
3580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3581   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3582   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3583
3584   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3585   arg2 = (Dali::Any::DeleteFunc)jarg2;
3586   if (arg1) (arg1)->mDeleteFunc = arg2;
3587 }
3588
3589
3590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3591   void * jresult ;
3592   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3593   Dali::Any::DeleteFunc result;
3594
3595   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3596   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3597   jresult = (void *)result;
3598   return jresult;
3599 }
3600
3601
3602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
3603   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3604
3605   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3606   {
3607     try {
3608       delete arg1;
3609     } catch (std::out_of_range& e) {
3610       {
3611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3612       };
3613     } catch (std::exception& e) {
3614       {
3615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3616       };
3617     } catch (...) {
3618       {
3619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3620       };
3621     }
3622   }
3623 }
3624
3625
3626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
3627   Dali::Any *arg1 = (Dali::Any *) 0 ;
3628   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
3629
3630   arg1 = (Dali::Any *)jarg1;
3631   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
3632   if (arg1) (arg1)->mContainer = arg2;
3633 }
3634
3635
3636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
3637   void * jresult ;
3638   Dali::Any *arg1 = (Dali::Any *) 0 ;
3639   Dali::Any::AnyContainerBase *result = 0 ;
3640
3641   arg1 = (Dali::Any *)jarg1;
3642   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
3643   jresult = (void *)result;
3644   return jresult;
3645 }
3646
3647
3648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
3649   char *arg1 = (char *) 0 ;
3650   char *arg2 = (char *) 0 ;
3651
3652   arg1 = (char *)jarg1;
3653   arg2 = (char *)jarg2;
3654   {
3655     try {
3656       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
3657     } catch (std::out_of_range& e) {
3658       {
3659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3660       };
3661     } catch (std::exception& e) {
3662       {
3663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3664       };
3665     } catch (...) {
3666       {
3667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3668       };
3669     }
3670   }
3671 }
3672
3673
3674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
3675   void * jresult ;
3676   char *arg1 = (char *) 0 ;
3677   char *arg2 = (char *) 0 ;
3678   Dali::DaliException *result = 0 ;
3679
3680   arg1 = (char *)jarg1;
3681   arg2 = (char *)jarg2;
3682   {
3683     try {
3684       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
3685     } catch (std::out_of_range& e) {
3686       {
3687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3688       };
3689     } catch (std::exception& e) {
3690       {
3691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3692       };
3693     } catch (...) {
3694       {
3695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3696       };
3697     }
3698   }
3699   jresult = (void *)result;
3700   return jresult;
3701 }
3702
3703
3704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
3705   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3706   char *arg2 = (char *) 0 ;
3707
3708   arg1 = (Dali::DaliException *)jarg1;
3709   arg2 = (char *)jarg2;
3710   {
3711     if (arg2) {
3712       arg1->location = (char const *) (new char[strlen((const char *)arg2)+1]);
3713       strcpy((char *)arg1->location, (const char *)arg2);
3714     } else {
3715       arg1->location = 0;
3716     }
3717   }
3718 }
3719
3720
3721 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
3722   char * jresult ;
3723   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3724   char *result = 0 ;
3725
3726   arg1 = (Dali::DaliException *)jarg1;
3727   result = (char *) ((arg1)->location);
3728   jresult = SWIG_csharp_string_callback((const char *)result);
3729   return jresult;
3730 }
3731
3732
3733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
3734   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3735   char *arg2 = (char *) 0 ;
3736
3737   arg1 = (Dali::DaliException *)jarg1;
3738   arg2 = (char *)jarg2;
3739   {
3740     if (arg2) {
3741       arg1->condition = (char const *) (new char[strlen((const char *)arg2)+1]);
3742       strcpy((char *)arg1->condition, (const char *)arg2);
3743     } else {
3744       arg1->condition = 0;
3745     }
3746   }
3747 }
3748
3749
3750 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
3751   char * jresult ;
3752   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3753   char *result = 0 ;
3754
3755   arg1 = (Dali::DaliException *)jarg1;
3756   result = (char *) ((arg1)->condition);
3757   jresult = SWIG_csharp_string_callback((const char *)result);
3758   return jresult;
3759 }
3760
3761
3762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
3763   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3764
3765   arg1 = (Dali::DaliException *)jarg1;
3766   {
3767     try {
3768       delete arg1;
3769     } catch (std::out_of_range& e) {
3770       {
3771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3772       };
3773     } catch (std::exception& e) {
3774       {
3775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3776       };
3777     } catch (...) {
3778       {
3779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3780       };
3781     }
3782   }
3783 }
3784
3785
3786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
3787   void * jresult ;
3788   Dali::Vector2 *result = 0 ;
3789
3790   {
3791     try {
3792       result = (Dali::Vector2 *)new Dali::Vector2();
3793     } catch (std::out_of_range& e) {
3794       {
3795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3796       };
3797     } catch (std::exception& e) {
3798       {
3799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3800       };
3801     } catch (...) {
3802       {
3803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3804       };
3805     }
3806   }
3807   jresult = (void *)result;
3808   return jresult;
3809 }
3810
3811
3812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
3813   void * jresult ;
3814   float arg1 ;
3815   float arg2 ;
3816   Dali::Vector2 *result = 0 ;
3817
3818   arg1 = (float)jarg1;
3819   arg2 = (float)jarg2;
3820   {
3821     try {
3822       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
3823     } catch (std::out_of_range& e) {
3824       {
3825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3826       };
3827     } catch (std::exception& e) {
3828       {
3829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3830       };
3831     } catch (...) {
3832       {
3833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3834       };
3835     }
3836   }
3837   jresult = (void *)result;
3838   return jresult;
3839 }
3840
3841
3842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
3843   void * jresult ;
3844   float *arg1 = (float *) 0 ;
3845   Dali::Vector2 *result = 0 ;
3846
3847   arg1 = jarg1;
3848   {
3849     try {
3850       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
3851     } catch (std::out_of_range& e) {
3852       {
3853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3854       };
3855     } catch (std::exception& e) {
3856       {
3857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3858       };
3859     } catch (...) {
3860       {
3861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3862       };
3863     }
3864   }
3865   jresult = (void *)result;
3866
3867
3868   return jresult;
3869 }
3870
3871
3872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
3873   void * jresult ;
3874   Dali::Vector3 *arg1 = 0 ;
3875   Dali::Vector2 *result = 0 ;
3876
3877   arg1 = (Dali::Vector3 *)jarg1;
3878   if (!arg1) {
3879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3880     return 0;
3881   }
3882   {
3883     try {
3884       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
3885     } catch (std::out_of_range& e) {
3886       {
3887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3888       };
3889     } catch (std::exception& e) {
3890       {
3891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3892       };
3893     } catch (...) {
3894       {
3895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3896       };
3897     }
3898   }
3899   jresult = (void *)result;
3900   return jresult;
3901 }
3902
3903
3904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
3905   void * jresult ;
3906   Dali::Vector4 *arg1 = 0 ;
3907   Dali::Vector2 *result = 0 ;
3908
3909   arg1 = (Dali::Vector4 *)jarg1;
3910   if (!arg1) {
3911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3912     return 0;
3913   }
3914   {
3915     try {
3916       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
3917     } catch (std::out_of_range& e) {
3918       {
3919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3920       };
3921     } catch (std::exception& e) {
3922       {
3923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3924       };
3925     } catch (...) {
3926       {
3927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3928       };
3929     }
3930   }
3931   jresult = (void *)result;
3932   return jresult;
3933 }
3934
3935
3936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
3937   void * jresult ;
3938   Dali::Vector2 *result = 0 ;
3939
3940   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
3941   jresult = (void *)result;
3942   return jresult;
3943 }
3944
3945
3946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
3947   void * jresult ;
3948   Dali::Vector2 *result = 0 ;
3949
3950   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
3951   jresult = (void *)result;
3952   return jresult;
3953 }
3954
3955
3956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
3957   void * jresult ;
3958   Dali::Vector2 *result = 0 ;
3959
3960   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
3961   jresult = (void *)result;
3962   return jresult;
3963 }
3964
3965
3966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
3967   void * jresult ;
3968   Dali::Vector2 *result = 0 ;
3969
3970   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
3971   jresult = (void *)result;
3972   return jresult;
3973 }
3974
3975
3976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
3977   void * jresult ;
3978   Dali::Vector2 *result = 0 ;
3979
3980   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
3981   jresult = (void *)result;
3982   return jresult;
3983 }
3984
3985
3986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
3987   void * jresult ;
3988   Dali::Vector2 *result = 0 ;
3989
3990   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
3991   jresult = (void *)result;
3992   return jresult;
3993 }
3994
3995
3996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
3997   void * jresult ;
3998   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3999   float *arg2 = (float *) 0 ;
4000   Dali::Vector2 *result = 0 ;
4001
4002   arg1 = (Dali::Vector2 *)jarg1;
4003   arg2 = jarg2;
4004   {
4005     try {
4006       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4007     } catch (std::out_of_range& e) {
4008       {
4009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4010       };
4011     } catch (std::exception& e) {
4012       {
4013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4014       };
4015     } catch (...) {
4016       {
4017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4018       };
4019     }
4020   }
4021   jresult = (void *)result;
4022
4023
4024   return jresult;
4025 }
4026
4027
4028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4029   void * jresult ;
4030   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4031   Dali::Vector3 *arg2 = 0 ;
4032   Dali::Vector2 *result = 0 ;
4033
4034   arg1 = (Dali::Vector2 *)jarg1;
4035   arg2 = (Dali::Vector3 *)jarg2;
4036   if (!arg2) {
4037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4038     return 0;
4039   }
4040   {
4041     try {
4042       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4043     } catch (std::out_of_range& e) {
4044       {
4045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4046       };
4047     } catch (std::exception& e) {
4048       {
4049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4050       };
4051     } catch (...) {
4052       {
4053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4054       };
4055     }
4056   }
4057   jresult = (void *)result;
4058   return jresult;
4059 }
4060
4061
4062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4063   void * jresult ;
4064   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4065   Dali::Vector4 *arg2 = 0 ;
4066   Dali::Vector2 *result = 0 ;
4067
4068   arg1 = (Dali::Vector2 *)jarg1;
4069   arg2 = (Dali::Vector4 *)jarg2;
4070   if (!arg2) {
4071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4072     return 0;
4073   }
4074   {
4075     try {
4076       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4077     } catch (std::out_of_range& e) {
4078       {
4079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4080       };
4081     } catch (std::exception& e) {
4082       {
4083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4084       };
4085     } catch (...) {
4086       {
4087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4088       };
4089     }
4090   }
4091   jresult = (void *)result;
4092   return jresult;
4093 }
4094
4095
4096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4097   void * jresult ;
4098   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4099   Dali::Vector2 *arg2 = 0 ;
4100   Dali::Vector2 result;
4101
4102   arg1 = (Dali::Vector2 *)jarg1;
4103   arg2 = (Dali::Vector2 *)jarg2;
4104   if (!arg2) {
4105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4106     return 0;
4107   }
4108   {
4109     try {
4110       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4111     } catch (std::out_of_range& e) {
4112       {
4113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4114       };
4115     } catch (std::exception& e) {
4116       {
4117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4118       };
4119     } catch (...) {
4120       {
4121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4122       };
4123     }
4124   }
4125   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4126   return jresult;
4127 }
4128
4129
4130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4131   void * jresult ;
4132   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4133   Dali::Vector2 *arg2 = 0 ;
4134   Dali::Vector2 *result = 0 ;
4135
4136   arg1 = (Dali::Vector2 *)jarg1;
4137   arg2 = (Dali::Vector2 *)jarg2;
4138   if (!arg2) {
4139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4140     return 0;
4141   }
4142   {
4143     try {
4144       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4145     } catch (std::out_of_range& e) {
4146       {
4147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4148       };
4149     } catch (std::exception& e) {
4150       {
4151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4152       };
4153     } catch (...) {
4154       {
4155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4156       };
4157     }
4158   }
4159   jresult = (void *)result;
4160   return jresult;
4161 }
4162
4163
4164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4165   void * jresult ;
4166   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4167   Dali::Vector2 *arg2 = 0 ;
4168   Dali::Vector2 result;
4169
4170   arg1 = (Dali::Vector2 *)jarg1;
4171   arg2 = (Dali::Vector2 *)jarg2;
4172   if (!arg2) {
4173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4174     return 0;
4175   }
4176   {
4177     try {
4178       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4179     } catch (std::out_of_range& e) {
4180       {
4181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4182       };
4183     } catch (std::exception& e) {
4184       {
4185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4186       };
4187     } catch (...) {
4188       {
4189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4190       };
4191     }
4192   }
4193   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4194   return jresult;
4195 }
4196
4197
4198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4199   void * jresult ;
4200   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4201   Dali::Vector2 *arg2 = 0 ;
4202   Dali::Vector2 *result = 0 ;
4203
4204   arg1 = (Dali::Vector2 *)jarg1;
4205   arg2 = (Dali::Vector2 *)jarg2;
4206   if (!arg2) {
4207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4208     return 0;
4209   }
4210   {
4211     try {
4212       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4213     } catch (std::out_of_range& e) {
4214       {
4215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4216       };
4217     } catch (std::exception& e) {
4218       {
4219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4220       };
4221     } catch (...) {
4222       {
4223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4224       };
4225     }
4226   }
4227   jresult = (void *)result;
4228   return jresult;
4229 }
4230
4231
4232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4233   void * jresult ;
4234   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4235   Dali::Vector2 *arg2 = 0 ;
4236   Dali::Vector2 result;
4237
4238   arg1 = (Dali::Vector2 *)jarg1;
4239   arg2 = (Dali::Vector2 *)jarg2;
4240   if (!arg2) {
4241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4242     return 0;
4243   }
4244   {
4245     try {
4246       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4247     } catch (std::out_of_range& e) {
4248       {
4249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4250       };
4251     } catch (std::exception& e) {
4252       {
4253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4254       };
4255     } catch (...) {
4256       {
4257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4258       };
4259     }
4260   }
4261   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4262   return jresult;
4263 }
4264
4265
4266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4267   void * jresult ;
4268   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4269   float arg2 ;
4270   Dali::Vector2 result;
4271
4272   arg1 = (Dali::Vector2 *)jarg1;
4273   arg2 = (float)jarg2;
4274   {
4275     try {
4276       result = ((Dali::Vector2 const *)arg1)->operator *(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_MultiplyAssign__SWIG_0(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_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4331   void * jresult ;
4332   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4333   float arg2 ;
4334   Dali::Vector2 *result = 0 ;
4335
4336   arg1 = (Dali::Vector2 *)jarg1;
4337   arg2 = (float)jarg2;
4338   {
4339     try {
4340       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4341     } catch (std::out_of_range& e) {
4342       {
4343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4344       };
4345     } catch (std::exception& e) {
4346       {
4347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4348       };
4349     } catch (...) {
4350       {
4351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4352       };
4353     }
4354   }
4355   jresult = (void *)result;
4356   return jresult;
4357 }
4358
4359
4360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4361   void * jresult ;
4362   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4363   Dali::Vector2 *arg2 = 0 ;
4364   Dali::Vector2 result;
4365
4366   arg1 = (Dali::Vector2 *)jarg1;
4367   arg2 = (Dali::Vector2 *)jarg2;
4368   if (!arg2) {
4369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4370     return 0;
4371   }
4372   {
4373     try {
4374       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*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_Divide__SWIG_1(void * jarg1, float jarg2) {
4395   void * jresult ;
4396   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4397   float arg2 ;
4398   Dali::Vector2 result;
4399
4400   arg1 = (Dali::Vector2 *)jarg1;
4401   arg2 = (float)jarg2;
4402   {
4403     try {
4404       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4405     } catch (std::out_of_range& e) {
4406       {
4407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4408       };
4409     } catch (std::exception& e) {
4410       {
4411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4412       };
4413     } catch (...) {
4414       {
4415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4416       };
4417     }
4418   }
4419   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4420   return jresult;
4421 }
4422
4423
4424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4425   void * jresult ;
4426   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4427   Dali::Vector2 *arg2 = 0 ;
4428   Dali::Vector2 *result = 0 ;
4429
4430   arg1 = (Dali::Vector2 *)jarg1;
4431   arg2 = (Dali::Vector2 *)jarg2;
4432   if (!arg2) {
4433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4434     return 0;
4435   }
4436   {
4437     try {
4438       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*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_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4459   void * jresult ;
4460   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4461   float arg2 ;
4462   Dali::Vector2 *result = 0 ;
4463
4464   arg1 = (Dali::Vector2 *)jarg1;
4465   arg2 = (float)jarg2;
4466   {
4467     try {
4468       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4469     } catch (std::out_of_range& e) {
4470       {
4471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4472       };
4473     } catch (std::exception& e) {
4474       {
4475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4476       };
4477     } catch (...) {
4478       {
4479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4480       };
4481     }
4482   }
4483   jresult = (void *)result;
4484   return jresult;
4485 }
4486
4487
4488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
4489   void * jresult ;
4490   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4491   Dali::Vector2 result;
4492
4493   arg1 = (Dali::Vector2 *)jarg1;
4494   {
4495     try {
4496       result = ((Dali::Vector2 const *)arg1)->operator -();
4497     } catch (std::out_of_range& e) {
4498       {
4499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4500       };
4501     } catch (std::exception& e) {
4502       {
4503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4504       };
4505     } catch (...) {
4506       {
4507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4508       };
4509     }
4510   }
4511   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4512   return jresult;
4513 }
4514
4515
4516 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
4517   unsigned int jresult ;
4518   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4519   Dali::Vector2 *arg2 = 0 ;
4520   bool result;
4521
4522   arg1 = (Dali::Vector2 *)jarg1;
4523   arg2 = (Dali::Vector2 *)jarg2;
4524   if (!arg2) {
4525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4526     return 0;
4527   }
4528   {
4529     try {
4530       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
4531     } catch (std::out_of_range& e) {
4532       {
4533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4534       };
4535     } catch (std::exception& e) {
4536       {
4537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4538       };
4539     } catch (...) {
4540       {
4541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4542       };
4543     }
4544   }
4545   jresult = result;
4546   return jresult;
4547 }
4548
4549
4550 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
4551   unsigned int jresult ;
4552   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4553   Dali::Vector2 *arg2 = 0 ;
4554   bool result;
4555
4556   arg1 = (Dali::Vector2 *)jarg1;
4557   arg2 = (Dali::Vector2 *)jarg2;
4558   if (!arg2) {
4559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4560     return 0;
4561   }
4562   {
4563     try {
4564       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
4565     } catch (std::out_of_range& e) {
4566       {
4567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4568       };
4569     } catch (std::exception& e) {
4570       {
4571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4572       };
4573     } catch (...) {
4574       {
4575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4576       };
4577     }
4578   }
4579   jresult = result;
4580   return jresult;
4581 }
4582
4583
4584 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
4585   float jresult ;
4586   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4587   unsigned int arg2 ;
4588   float *result = 0 ;
4589
4590   arg1 = (Dali::Vector2 *)jarg1;
4591   arg2 = (unsigned int)jarg2;
4592   {
4593     try {
4594       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
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 = *result;
4610   return jresult;
4611 }
4612
4613
4614 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
4615   float jresult ;
4616   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4617   float result;
4618
4619   arg1 = (Dali::Vector2 *)jarg1;
4620   {
4621     try {
4622       result = (float)((Dali::Vector2 const *)arg1)->Length();
4623     } catch (std::out_of_range& e) {
4624       {
4625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4626       };
4627     } catch (std::exception& e) {
4628       {
4629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4630       };
4631     } catch (...) {
4632       {
4633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4634       };
4635     }
4636   }
4637   jresult = result;
4638   return jresult;
4639 }
4640
4641
4642 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
4643   float jresult ;
4644   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4645   float result;
4646
4647   arg1 = (Dali::Vector2 *)jarg1;
4648   {
4649     try {
4650       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
4651     } catch (std::out_of_range& e) {
4652       {
4653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4654       };
4655     } catch (std::exception& e) {
4656       {
4657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4658       };
4659     } catch (...) {
4660       {
4661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4662       };
4663     }
4664   }
4665   jresult = result;
4666   return jresult;
4667 }
4668
4669
4670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
4671   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4672
4673   arg1 = (Dali::Vector2 *)jarg1;
4674   {
4675     try {
4676       (arg1)->Normalize();
4677     } catch (std::out_of_range& e) {
4678       {
4679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4680       };
4681     } catch (std::exception& e) {
4682       {
4683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4684       };
4685     } catch (...) {
4686       {
4687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4688       };
4689     }
4690   }
4691 }
4692
4693
4694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
4695   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4696   Dali::Vector2 *arg2 = 0 ;
4697   Dali::Vector2 *arg3 = 0 ;
4698
4699   arg1 = (Dali::Vector2 *)jarg1;
4700   arg2 = (Dali::Vector2 *)jarg2;
4701   if (!arg2) {
4702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4703     return ;
4704   }
4705   arg3 = (Dali::Vector2 *)jarg3;
4706   if (!arg3) {
4707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4708     return ;
4709   }
4710   {
4711     try {
4712       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
4713     } catch (std::out_of_range& e) {
4714       {
4715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4716       };
4717     } catch (std::exception& e) {
4718       {
4719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4720       };
4721     } catch (...) {
4722       {
4723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4724       };
4725     }
4726   }
4727 }
4728
4729
4730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
4731   void * jresult ;
4732   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4733   float *result = 0 ;
4734
4735   arg1 = (Dali::Vector2 *)jarg1;
4736   {
4737     try {
4738       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
4739     } catch (std::out_of_range& e) {
4740       {
4741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4742       };
4743     } catch (std::exception& e) {
4744       {
4745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4746       };
4747     } catch (...) {
4748       {
4749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4750       };
4751     }
4752   }
4753   jresult = (void *)result;
4754   return jresult;
4755 }
4756
4757
4758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
4759   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4760   float arg2 ;
4761
4762   arg1 = (Dali::Vector2 *)jarg1;
4763   arg2 = (float)jarg2;
4764   if (arg1) (arg1)->x = arg2;
4765 }
4766
4767
4768 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
4769   float jresult ;
4770   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4771   float result;
4772
4773   arg1 = (Dali::Vector2 *)jarg1;
4774   result = (float) ((arg1)->x);
4775   jresult = result;
4776   return jresult;
4777 }
4778
4779
4780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
4781   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4782   float arg2 ;
4783
4784   arg1 = (Dali::Vector2 *)jarg1;
4785   arg2 = (float)jarg2;
4786   if (arg1) (arg1)->width = arg2;
4787 }
4788
4789
4790 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
4791   float jresult ;
4792   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4793   float result;
4794
4795   arg1 = (Dali::Vector2 *)jarg1;
4796   result = (float) ((arg1)->width);
4797   jresult = result;
4798   return jresult;
4799 }
4800
4801
4802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
4803   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4804   float arg2 ;
4805
4806   arg1 = (Dali::Vector2 *)jarg1;
4807   arg2 = (float)jarg2;
4808   if (arg1) (arg1)->y = arg2;
4809 }
4810
4811
4812 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
4813   float jresult ;
4814   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4815   float result;
4816
4817   arg1 = (Dali::Vector2 *)jarg1;
4818   result = (float) ((arg1)->y);
4819   jresult = result;
4820   return jresult;
4821 }
4822
4823
4824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
4825   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4826   float arg2 ;
4827
4828   arg1 = (Dali::Vector2 *)jarg1;
4829   arg2 = (float)jarg2;
4830   if (arg1) (arg1)->height = arg2;
4831 }
4832
4833
4834 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
4835   float jresult ;
4836   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4837   float result;
4838
4839   arg1 = (Dali::Vector2 *)jarg1;
4840   result = (float) ((arg1)->height);
4841   jresult = result;
4842   return jresult;
4843 }
4844
4845
4846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
4847   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4848
4849   arg1 = (Dali::Vector2 *)jarg1;
4850   {
4851     try {
4852       delete arg1;
4853     } catch (std::out_of_range& e) {
4854       {
4855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4856       };
4857     } catch (std::exception& e) {
4858       {
4859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4860       };
4861     } catch (...) {
4862       {
4863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4864       };
4865     }
4866   }
4867 }
4868
4869
4870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
4871   void * jresult ;
4872   Dali::Vector2 *arg1 = 0 ;
4873   Dali::Vector2 *arg2 = 0 ;
4874   Dali::Vector2 result;
4875
4876   arg1 = (Dali::Vector2 *)jarg1;
4877   if (!arg1) {
4878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4879     return 0;
4880   }
4881   arg2 = (Dali::Vector2 *)jarg2;
4882   if (!arg2) {
4883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4884     return 0;
4885   }
4886   {
4887     try {
4888       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4889     } catch (std::out_of_range& e) {
4890       {
4891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4892       };
4893     } catch (std::exception& e) {
4894       {
4895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4896       };
4897     } catch (...) {
4898       {
4899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4900       };
4901     }
4902   }
4903   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4904   return jresult;
4905 }
4906
4907
4908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
4909   void * jresult ;
4910   Dali::Vector2 *arg1 = 0 ;
4911   Dali::Vector2 *arg2 = 0 ;
4912   Dali::Vector2 result;
4913
4914   arg1 = (Dali::Vector2 *)jarg1;
4915   if (!arg1) {
4916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4917     return 0;
4918   }
4919   arg2 = (Dali::Vector2 *)jarg2;
4920   if (!arg2) {
4921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4922     return 0;
4923   }
4924   {
4925     try {
4926       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4927     } catch (std::out_of_range& e) {
4928       {
4929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4930       };
4931     } catch (std::exception& e) {
4932       {
4933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4934       };
4935     } catch (...) {
4936       {
4937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4938       };
4939     }
4940   }
4941   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4942   return jresult;
4943 }
4944
4945
4946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
4947   void * jresult ;
4948   Dali::Vector2 *arg1 = 0 ;
4949   float *arg2 = 0 ;
4950   float *arg3 = 0 ;
4951   float temp2 ;
4952   float temp3 ;
4953   Dali::Vector2 result;
4954
4955   arg1 = (Dali::Vector2 *)jarg1;
4956   if (!arg1) {
4957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4958     return 0;
4959   }
4960   temp2 = (float)jarg2;
4961   arg2 = &temp2;
4962   temp3 = (float)jarg3;
4963   arg3 = &temp3;
4964   {
4965     try {
4966       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
4967     } catch (std::out_of_range& e) {
4968       {
4969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4970       };
4971     } catch (std::exception& e) {
4972       {
4973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4974       };
4975     } catch (...) {
4976       {
4977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4978       };
4979     }
4980   }
4981   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4982   return jresult;
4983 }
4984
4985
4986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
4987   void * jresult ;
4988   Dali::Vector3 *result = 0 ;
4989
4990   {
4991     try {
4992       result = (Dali::Vector3 *)new Dali::Vector3();
4993     } catch (std::out_of_range& e) {
4994       {
4995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4996       };
4997     } catch (std::exception& e) {
4998       {
4999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5000       };
5001     } catch (...) {
5002       {
5003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5004       };
5005     }
5006   }
5007   jresult = (void *)result;
5008   return jresult;
5009 }
5010
5011
5012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5013   void * jresult ;
5014   float arg1 ;
5015   float arg2 ;
5016   float arg3 ;
5017   Dali::Vector3 *result = 0 ;
5018
5019   arg1 = (float)jarg1;
5020   arg2 = (float)jarg2;
5021   arg3 = (float)jarg3;
5022   {
5023     try {
5024       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
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 = (void *)result;
5040   return jresult;
5041 }
5042
5043
5044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5045   void * jresult ;
5046   float *arg1 = (float *) 0 ;
5047   Dali::Vector3 *result = 0 ;
5048
5049   arg1 = jarg1;
5050   {
5051     try {
5052       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5053     } catch (std::out_of_range& e) {
5054       {
5055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5056       };
5057     } catch (std::exception& e) {
5058       {
5059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5060       };
5061     } catch (...) {
5062       {
5063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5064       };
5065     }
5066   }
5067   jresult = (void *)result;
5068
5069
5070   return jresult;
5071 }
5072
5073
5074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5075   void * jresult ;
5076   Dali::Vector2 *arg1 = 0 ;
5077   Dali::Vector3 *result = 0 ;
5078
5079   arg1 = (Dali::Vector2 *)jarg1;
5080   if (!arg1) {
5081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5082     return 0;
5083   }
5084   {
5085     try {
5086       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5087     } catch (std::out_of_range& e) {
5088       {
5089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5090       };
5091     } catch (std::exception& e) {
5092       {
5093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5094       };
5095     } catch (...) {
5096       {
5097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5098       };
5099     }
5100   }
5101   jresult = (void *)result;
5102   return jresult;
5103 }
5104
5105
5106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5107   void * jresult ;
5108   Dali::Vector4 *arg1 = 0 ;
5109   Dali::Vector3 *result = 0 ;
5110
5111   arg1 = (Dali::Vector4 *)jarg1;
5112   if (!arg1) {
5113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5114     return 0;
5115   }
5116   {
5117     try {
5118       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5119     } catch (std::out_of_range& e) {
5120       {
5121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5122       };
5123     } catch (std::exception& e) {
5124       {
5125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5126       };
5127     } catch (...) {
5128       {
5129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5130       };
5131     }
5132   }
5133   jresult = (void *)result;
5134   return jresult;
5135 }
5136
5137
5138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5139   void * jresult ;
5140   Dali::Vector3 *result = 0 ;
5141
5142   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5143   jresult = (void *)result;
5144   return jresult;
5145 }
5146
5147
5148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5149   void * jresult ;
5150   Dali::Vector3 *result = 0 ;
5151
5152   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5153   jresult = (void *)result;
5154   return jresult;
5155 }
5156
5157
5158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5159   void * jresult ;
5160   Dali::Vector3 *result = 0 ;
5161
5162   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5163   jresult = (void *)result;
5164   return jresult;
5165 }
5166
5167
5168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5169   void * jresult ;
5170   Dali::Vector3 *result = 0 ;
5171
5172   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5173   jresult = (void *)result;
5174   return jresult;
5175 }
5176
5177
5178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5179   void * jresult ;
5180   Dali::Vector3 *result = 0 ;
5181
5182   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5183   jresult = (void *)result;
5184   return jresult;
5185 }
5186
5187
5188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5189   void * jresult ;
5190   Dali::Vector3 *result = 0 ;
5191
5192   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5193   jresult = (void *)result;
5194   return jresult;
5195 }
5196
5197
5198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5199   void * jresult ;
5200   Dali::Vector3 *result = 0 ;
5201
5202   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5203   jresult = (void *)result;
5204   return jresult;
5205 }
5206
5207
5208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5209   void * jresult ;
5210   Dali::Vector3 *result = 0 ;
5211
5212   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5213   jresult = (void *)result;
5214   return jresult;
5215 }
5216
5217
5218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5219   void * jresult ;
5220   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5221   float *arg2 = (float *) 0 ;
5222   Dali::Vector3 *result = 0 ;
5223
5224   arg1 = (Dali::Vector3 *)jarg1;
5225   arg2 = jarg2;
5226   {
5227     try {
5228       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5229     } catch (std::out_of_range& e) {
5230       {
5231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5232       };
5233     } catch (std::exception& e) {
5234       {
5235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5236       };
5237     } catch (...) {
5238       {
5239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5240       };
5241     }
5242   }
5243   jresult = (void *)result;
5244
5245
5246   return jresult;
5247 }
5248
5249
5250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5251   void * jresult ;
5252   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5253   Dali::Vector2 *arg2 = 0 ;
5254   Dali::Vector3 *result = 0 ;
5255
5256   arg1 = (Dali::Vector3 *)jarg1;
5257   arg2 = (Dali::Vector2 *)jarg2;
5258   if (!arg2) {
5259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5260     return 0;
5261   }
5262   {
5263     try {
5264       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5265     } catch (std::out_of_range& e) {
5266       {
5267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5268       };
5269     } catch (std::exception& e) {
5270       {
5271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5272       };
5273     } catch (...) {
5274       {
5275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5276       };
5277     }
5278   }
5279   jresult = (void *)result;
5280   return jresult;
5281 }
5282
5283
5284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5285   void * jresult ;
5286   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5287   Dali::Vector4 *arg2 = 0 ;
5288   Dali::Vector3 *result = 0 ;
5289
5290   arg1 = (Dali::Vector3 *)jarg1;
5291   arg2 = (Dali::Vector4 *)jarg2;
5292   if (!arg2) {
5293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5294     return 0;
5295   }
5296   {
5297     try {
5298       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5299     } catch (std::out_of_range& e) {
5300       {
5301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5302       };
5303     } catch (std::exception& e) {
5304       {
5305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5306       };
5307     } catch (...) {
5308       {
5309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5310       };
5311     }
5312   }
5313   jresult = (void *)result;
5314   return jresult;
5315 }
5316
5317
5318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5319   void * jresult ;
5320   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5321   Dali::Vector3 *arg2 = 0 ;
5322   Dali::Vector3 result;
5323
5324   arg1 = (Dali::Vector3 *)jarg1;
5325   arg2 = (Dali::Vector3 *)jarg2;
5326   if (!arg2) {
5327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5328     return 0;
5329   }
5330   {
5331     try {
5332       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5333     } catch (std::out_of_range& e) {
5334       {
5335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5336       };
5337     } catch (std::exception& e) {
5338       {
5339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5340       };
5341     } catch (...) {
5342       {
5343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5344       };
5345     }
5346   }
5347   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5348   return jresult;
5349 }
5350
5351
5352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5353   void * jresult ;
5354   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5355   Dali::Vector3 *arg2 = 0 ;
5356   Dali::Vector3 *result = 0 ;
5357
5358   arg1 = (Dali::Vector3 *)jarg1;
5359   arg2 = (Dali::Vector3 *)jarg2;
5360   if (!arg2) {
5361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5362     return 0;
5363   }
5364   {
5365     try {
5366       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
5367     } catch (std::out_of_range& e) {
5368       {
5369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5370       };
5371     } catch (std::exception& e) {
5372       {
5373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5374       };
5375     } catch (...) {
5376       {
5377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5378       };
5379     }
5380   }
5381   jresult = (void *)result;
5382   return jresult;
5383 }
5384
5385
5386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5387   void * jresult ;
5388   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5389   Dali::Vector3 *arg2 = 0 ;
5390   Dali::Vector3 result;
5391
5392   arg1 = (Dali::Vector3 *)jarg1;
5393   arg2 = (Dali::Vector3 *)jarg2;
5394   if (!arg2) {
5395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5396     return 0;
5397   }
5398   {
5399     try {
5400       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
5401     } catch (std::out_of_range& e) {
5402       {
5403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5404       };
5405     } catch (std::exception& e) {
5406       {
5407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5408       };
5409     } catch (...) {
5410       {
5411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5412       };
5413     }
5414   }
5415   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5416   return jresult;
5417 }
5418
5419
5420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
5421   void * jresult ;
5422   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5423   Dali::Vector3 *arg2 = 0 ;
5424   Dali::Vector3 *result = 0 ;
5425
5426   arg1 = (Dali::Vector3 *)jarg1;
5427   arg2 = (Dali::Vector3 *)jarg2;
5428   if (!arg2) {
5429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5430     return 0;
5431   }
5432   {
5433     try {
5434       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
5435     } catch (std::out_of_range& e) {
5436       {
5437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5438       };
5439     } catch (std::exception& e) {
5440       {
5441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5442       };
5443     } catch (...) {
5444       {
5445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5446       };
5447     }
5448   }
5449   jresult = (void *)result;
5450   return jresult;
5451 }
5452
5453
5454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
5455   void * jresult ;
5456   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5457   Dali::Vector3 *arg2 = 0 ;
5458   Dali::Vector3 result;
5459
5460   arg1 = (Dali::Vector3 *)jarg1;
5461   arg2 = (Dali::Vector3 *)jarg2;
5462   if (!arg2) {
5463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5464     return 0;
5465   }
5466   {
5467     try {
5468       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
5469     } catch (std::out_of_range& e) {
5470       {
5471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5472       };
5473     } catch (std::exception& e) {
5474       {
5475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5476       };
5477     } catch (...) {
5478       {
5479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5480       };
5481     }
5482   }
5483   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5484   return jresult;
5485 }
5486
5487
5488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
5489   void * jresult ;
5490   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5491   float arg2 ;
5492   Dali::Vector3 result;
5493
5494   arg1 = (Dali::Vector3 *)jarg1;
5495   arg2 = (float)jarg2;
5496   {
5497     try {
5498       result = ((Dali::Vector3 const *)arg1)->operator *(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_MultiplyAssign__SWIG_0(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_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
5553   void * jresult ;
5554   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5555   float arg2 ;
5556   Dali::Vector3 *result = 0 ;
5557
5558   arg1 = (Dali::Vector3 *)jarg1;
5559   arg2 = (float)jarg2;
5560   {
5561     try {
5562       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
5563     } catch (std::out_of_range& e) {
5564       {
5565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5566       };
5567     } catch (std::exception& e) {
5568       {
5569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5570       };
5571     } catch (...) {
5572       {
5573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5574       };
5575     }
5576   }
5577   jresult = (void *)result;
5578   return jresult;
5579 }
5580
5581
5582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
5583   void * jresult ;
5584   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5585   Dali::Quaternion *arg2 = 0 ;
5586   Dali::Vector3 *result = 0 ;
5587
5588   arg1 = (Dali::Vector3 *)jarg1;
5589   arg2 = (Dali::Quaternion *)jarg2;
5590   if (!arg2) {
5591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
5592     return 0;
5593   }
5594   {
5595     try {
5596       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*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 = (void *)result;
5612   return jresult;
5613 }
5614
5615
5616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__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;
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 const *)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 = new Dali::Vector3((const Dali::Vector3 &)result);
5646   return jresult;
5647 }
5648
5649
5650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
5651   void * jresult ;
5652   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5653   float arg2 ;
5654   Dali::Vector3 result;
5655
5656   arg1 = (Dali::Vector3 *)jarg1;
5657   arg2 = (float)jarg2;
5658   {
5659     try {
5660       result = ((Dali::Vector3 const *)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 = new Dali::Vector3((const Dali::Vector3 &)result);
5676   return jresult;
5677 }
5678
5679
5680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
5681   void * jresult ;
5682   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5683   Dali::Vector3 *arg2 = 0 ;
5684   Dali::Vector3 *result = 0 ;
5685
5686   arg1 = (Dali::Vector3 *)jarg1;
5687   arg2 = (Dali::Vector3 *)jarg2;
5688   if (!arg2) {
5689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5690     return 0;
5691   }
5692   {
5693     try {
5694       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 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_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
5715   void * jresult ;
5716   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5717   float arg2 ;
5718   Dali::Vector3 *result = 0 ;
5719
5720   arg1 = (Dali::Vector3 *)jarg1;
5721   arg2 = (float)jarg2;
5722   {
5723     try {
5724       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
5725     } catch (std::out_of_range& e) {
5726       {
5727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5728       };
5729     } catch (std::exception& e) {
5730       {
5731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5732       };
5733     } catch (...) {
5734       {
5735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5736       };
5737     }
5738   }
5739   jresult = (void *)result;
5740   return jresult;
5741 }
5742
5743
5744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
5745   void * jresult ;
5746   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5747   Dali::Vector3 result;
5748
5749   arg1 = (Dali::Vector3 *)jarg1;
5750   {
5751     try {
5752       result = ((Dali::Vector3 const *)arg1)->operator -();
5753     } catch (std::out_of_range& e) {
5754       {
5755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5756       };
5757     } catch (std::exception& e) {
5758       {
5759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5760       };
5761     } catch (...) {
5762       {
5763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5764       };
5765     }
5766   }
5767   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5768   return jresult;
5769 }
5770
5771
5772 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
5773   unsigned int jresult ;
5774   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5775   Dali::Vector3 *arg2 = 0 ;
5776   bool result;
5777
5778   arg1 = (Dali::Vector3 *)jarg1;
5779   arg2 = (Dali::Vector3 *)jarg2;
5780   if (!arg2) {
5781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5782     return 0;
5783   }
5784   {
5785     try {
5786       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
5787     } catch (std::out_of_range& e) {
5788       {
5789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5790       };
5791     } catch (std::exception& e) {
5792       {
5793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5794       };
5795     } catch (...) {
5796       {
5797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5798       };
5799     }
5800   }
5801   jresult = result;
5802   return jresult;
5803 }
5804
5805
5806 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
5807   unsigned int jresult ;
5808   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5809   Dali::Vector3 *arg2 = 0 ;
5810   bool result;
5811
5812   arg1 = (Dali::Vector3 *)jarg1;
5813   arg2 = (Dali::Vector3 *)jarg2;
5814   if (!arg2) {
5815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5816     return 0;
5817   }
5818   {
5819     try {
5820       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
5821     } catch (std::out_of_range& e) {
5822       {
5823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5824       };
5825     } catch (std::exception& e) {
5826       {
5827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5828       };
5829     } catch (...) {
5830       {
5831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5832       };
5833     }
5834   }
5835   jresult = result;
5836   return jresult;
5837 }
5838
5839
5840 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5841   float jresult ;
5842   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5843   unsigned int arg2 ;
5844   float *result = 0 ;
5845
5846   arg1 = (Dali::Vector3 *)jarg1;
5847   arg2 = (unsigned int)jarg2;
5848   {
5849     try {
5850       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
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 = *result;
5866   return jresult;
5867 }
5868
5869
5870 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
5871   float jresult ;
5872   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5873   Dali::Vector3 *arg2 = 0 ;
5874   float 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 = (float)((Dali::Vector3 const *)arg1)->Dot((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 void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
5905   void * jresult ;
5906   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5907   Dali::Vector3 *arg2 = 0 ;
5908   Dali::Vector3 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 = ((Dali::Vector3 const *)arg1)->Cross((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 = new Dali::Vector3((const Dali::Vector3 &)result);
5934   return jresult;
5935 }
5936
5937
5938 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
5939   float jresult ;
5940   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5941   float result;
5942
5943   arg1 = (Dali::Vector3 *)jarg1;
5944   {
5945     try {
5946       result = (float)((Dali::Vector3 const *)arg1)->Length();
5947     } catch (std::out_of_range& e) {
5948       {
5949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5950       };
5951     } catch (std::exception& e) {
5952       {
5953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5954       };
5955     } catch (...) {
5956       {
5957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5958       };
5959     }
5960   }
5961   jresult = result;
5962   return jresult;
5963 }
5964
5965
5966 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
5967   float jresult ;
5968   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5969   float result;
5970
5971   arg1 = (Dali::Vector3 *)jarg1;
5972   {
5973     try {
5974       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
5975     } catch (std::out_of_range& e) {
5976       {
5977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5978       };
5979     } catch (std::exception& e) {
5980       {
5981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5982       };
5983     } catch (...) {
5984       {
5985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5986       };
5987     }
5988   }
5989   jresult = result;
5990   return jresult;
5991 }
5992
5993
5994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
5995   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5996
5997   arg1 = (Dali::Vector3 *)jarg1;
5998   {
5999     try {
6000       (arg1)->Normalize();
6001     } catch (std::out_of_range& e) {
6002       {
6003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6004       };
6005     } catch (std::exception& e) {
6006       {
6007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6008       };
6009     } catch (...) {
6010       {
6011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6012       };
6013     }
6014   }
6015 }
6016
6017
6018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6019   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6020   Dali::Vector3 *arg2 = 0 ;
6021   Dali::Vector3 *arg3 = 0 ;
6022
6023   arg1 = (Dali::Vector3 *)jarg1;
6024   arg2 = (Dali::Vector3 *)jarg2;
6025   if (!arg2) {
6026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6027     return ;
6028   }
6029   arg3 = (Dali::Vector3 *)jarg3;
6030   if (!arg3) {
6031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6032     return ;
6033   }
6034   {
6035     try {
6036       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6037     } catch (std::out_of_range& e) {
6038       {
6039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6040       };
6041     } catch (std::exception& e) {
6042       {
6043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6044       };
6045     } catch (...) {
6046       {
6047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6048       };
6049     }
6050   }
6051 }
6052
6053
6054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6055   void * jresult ;
6056   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6057   float *result = 0 ;
6058
6059   arg1 = (Dali::Vector3 *)jarg1;
6060   {
6061     try {
6062       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6063     } catch (std::out_of_range& e) {
6064       {
6065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6066       };
6067     } catch (std::exception& e) {
6068       {
6069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6070       };
6071     } catch (...) {
6072       {
6073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6074       };
6075     }
6076   }
6077   jresult = (void *)result;
6078   return jresult;
6079 }
6080
6081
6082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6083   void * jresult ;
6084   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6085   Dali::Vector2 *result = 0 ;
6086
6087   arg1 = (Dali::Vector3 *)jarg1;
6088   {
6089     try {
6090       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6091     } catch (std::out_of_range& e) {
6092       {
6093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6094       };
6095     } catch (std::exception& e) {
6096       {
6097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6098       };
6099     } catch (...) {
6100       {
6101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6102       };
6103     }
6104   }
6105   jresult = (void *)result;
6106   return jresult;
6107 }
6108
6109
6110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6111   void * jresult ;
6112   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6113   Dali::Vector2 *result = 0 ;
6114
6115   arg1 = (Dali::Vector3 *)jarg1;
6116   {
6117     try {
6118       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6119     } catch (std::out_of_range& e) {
6120       {
6121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6122       };
6123     } catch (std::exception& e) {
6124       {
6125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6126       };
6127     } catch (...) {
6128       {
6129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6130       };
6131     }
6132   }
6133   jresult = (void *)result;
6134   return jresult;
6135 }
6136
6137
6138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6139   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6140   float arg2 ;
6141
6142   arg1 = (Dali::Vector3 *)jarg1;
6143   arg2 = (float)jarg2;
6144   if (arg1) (arg1)->x = arg2;
6145 }
6146
6147
6148 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6149   float jresult ;
6150   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6151   float result;
6152
6153   arg1 = (Dali::Vector3 *)jarg1;
6154   result = (float) ((arg1)->x);
6155   jresult = result;
6156   return jresult;
6157 }
6158
6159
6160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6161   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6162   float arg2 ;
6163
6164   arg1 = (Dali::Vector3 *)jarg1;
6165   arg2 = (float)jarg2;
6166   if (arg1) (arg1)->width = arg2;
6167 }
6168
6169
6170 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6171   float jresult ;
6172   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6173   float result;
6174
6175   arg1 = (Dali::Vector3 *)jarg1;
6176   result = (float) ((arg1)->width);
6177   jresult = result;
6178   return jresult;
6179 }
6180
6181
6182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6183   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6184   float arg2 ;
6185
6186   arg1 = (Dali::Vector3 *)jarg1;
6187   arg2 = (float)jarg2;
6188   if (arg1) (arg1)->r = arg2;
6189 }
6190
6191
6192 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6193   float jresult ;
6194   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6195   float result;
6196
6197   arg1 = (Dali::Vector3 *)jarg1;
6198   result = (float) ((arg1)->r);
6199   jresult = result;
6200   return jresult;
6201 }
6202
6203
6204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6205   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6206   float arg2 ;
6207
6208   arg1 = (Dali::Vector3 *)jarg1;
6209   arg2 = (float)jarg2;
6210   if (arg1) (arg1)->y = arg2;
6211 }
6212
6213
6214 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6215   float jresult ;
6216   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6217   float result;
6218
6219   arg1 = (Dali::Vector3 *)jarg1;
6220   result = (float) ((arg1)->y);
6221   jresult = result;
6222   return jresult;
6223 }
6224
6225
6226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6227   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6228   float arg2 ;
6229
6230   arg1 = (Dali::Vector3 *)jarg1;
6231   arg2 = (float)jarg2;
6232   if (arg1) (arg1)->height = arg2;
6233 }
6234
6235
6236 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
6237   float jresult ;
6238   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6239   float result;
6240
6241   arg1 = (Dali::Vector3 *)jarg1;
6242   result = (float) ((arg1)->height);
6243   jresult = result;
6244   return jresult;
6245 }
6246
6247
6248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
6249   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6250   float arg2 ;
6251
6252   arg1 = (Dali::Vector3 *)jarg1;
6253   arg2 = (float)jarg2;
6254   if (arg1) (arg1)->g = arg2;
6255 }
6256
6257
6258 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
6259   float jresult ;
6260   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6261   float result;
6262
6263   arg1 = (Dali::Vector3 *)jarg1;
6264   result = (float) ((arg1)->g);
6265   jresult = result;
6266   return jresult;
6267 }
6268
6269
6270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
6271   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6272   float arg2 ;
6273
6274   arg1 = (Dali::Vector3 *)jarg1;
6275   arg2 = (float)jarg2;
6276   if (arg1) (arg1)->z = arg2;
6277 }
6278
6279
6280 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
6281   float jresult ;
6282   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6283   float result;
6284
6285   arg1 = (Dali::Vector3 *)jarg1;
6286   result = (float) ((arg1)->z);
6287   jresult = result;
6288   return jresult;
6289 }
6290
6291
6292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
6293   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6294   float arg2 ;
6295
6296   arg1 = (Dali::Vector3 *)jarg1;
6297   arg2 = (float)jarg2;
6298   if (arg1) (arg1)->depth = arg2;
6299 }
6300
6301
6302 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
6303   float jresult ;
6304   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6305   float result;
6306
6307   arg1 = (Dali::Vector3 *)jarg1;
6308   result = (float) ((arg1)->depth);
6309   jresult = result;
6310   return jresult;
6311 }
6312
6313
6314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
6315   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6316   float arg2 ;
6317
6318   arg1 = (Dali::Vector3 *)jarg1;
6319   arg2 = (float)jarg2;
6320   if (arg1) (arg1)->b = arg2;
6321 }
6322
6323
6324 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
6325   float jresult ;
6326   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6327   float result;
6328
6329   arg1 = (Dali::Vector3 *)jarg1;
6330   result = (float) ((arg1)->b);
6331   jresult = result;
6332   return jresult;
6333 }
6334
6335
6336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
6337   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6338
6339   arg1 = (Dali::Vector3 *)jarg1;
6340   {
6341     try {
6342       delete arg1;
6343     } catch (std::out_of_range& e) {
6344       {
6345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6346       };
6347     } catch (std::exception& e) {
6348       {
6349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6350       };
6351     } catch (...) {
6352       {
6353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6354       };
6355     }
6356   }
6357 }
6358
6359
6360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
6361   void * jresult ;
6362   Dali::Vector3 *arg1 = 0 ;
6363   Dali::Vector3 *arg2 = 0 ;
6364   Dali::Vector3 result;
6365
6366   arg1 = (Dali::Vector3 *)jarg1;
6367   if (!arg1) {
6368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6369     return 0;
6370   }
6371   arg2 = (Dali::Vector3 *)jarg2;
6372   if (!arg2) {
6373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6374     return 0;
6375   }
6376   {
6377     try {
6378       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6379     } catch (std::out_of_range& e) {
6380       {
6381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6382       };
6383     } catch (std::exception& e) {
6384       {
6385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6386       };
6387     } catch (...) {
6388       {
6389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6390       };
6391     }
6392   }
6393   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6394   return jresult;
6395 }
6396
6397
6398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
6399   void * jresult ;
6400   Dali::Vector3 *arg1 = 0 ;
6401   Dali::Vector3 *arg2 = 0 ;
6402   Dali::Vector3 result;
6403
6404   arg1 = (Dali::Vector3 *)jarg1;
6405   if (!arg1) {
6406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6407     return 0;
6408   }
6409   arg2 = (Dali::Vector3 *)jarg2;
6410   if (!arg2) {
6411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6412     return 0;
6413   }
6414   {
6415     try {
6416       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6417     } catch (std::out_of_range& e) {
6418       {
6419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6420       };
6421     } catch (std::exception& e) {
6422       {
6423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6424       };
6425     } catch (...) {
6426       {
6427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6428       };
6429     }
6430   }
6431   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6432   return jresult;
6433 }
6434
6435
6436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
6437   void * jresult ;
6438   Dali::Vector3 *arg1 = 0 ;
6439   float *arg2 = 0 ;
6440   float *arg3 = 0 ;
6441   float temp2 ;
6442   float temp3 ;
6443   Dali::Vector3 result;
6444
6445   arg1 = (Dali::Vector3 *)jarg1;
6446   if (!arg1) {
6447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6448     return 0;
6449   }
6450   temp2 = (float)jarg2;
6451   arg2 = &temp2;
6452   temp3 = (float)jarg3;
6453   arg3 = &temp3;
6454   {
6455     try {
6456       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
6457     } catch (std::out_of_range& e) {
6458       {
6459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6460       };
6461     } catch (std::exception& e) {
6462       {
6463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6464       };
6465     } catch (...) {
6466       {
6467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6468       };
6469     }
6470   }
6471   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6472   return jresult;
6473 }
6474
6475
6476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
6477   void * jresult ;
6478   Dali::Vector4 *result = 0 ;
6479
6480   {
6481     try {
6482       result = (Dali::Vector4 *)new Dali::Vector4();
6483     } catch (std::out_of_range& e) {
6484       {
6485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6486       };
6487     } catch (std::exception& e) {
6488       {
6489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6490       };
6491     } catch (...) {
6492       {
6493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6494       };
6495     }
6496   }
6497   jresult = (void *)result;
6498   return jresult;
6499 }
6500
6501
6502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
6503   void * jresult ;
6504   float arg1 ;
6505   float arg2 ;
6506   float arg3 ;
6507   float arg4 ;
6508   Dali::Vector4 *result = 0 ;
6509
6510   arg1 = (float)jarg1;
6511   arg2 = (float)jarg2;
6512   arg3 = (float)jarg3;
6513   arg4 = (float)jarg4;
6514   {
6515     try {
6516       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
6517     } catch (std::out_of_range& e) {
6518       {
6519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6520       };
6521     } catch (std::exception& e) {
6522       {
6523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6524       };
6525     } catch (...) {
6526       {
6527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6528       };
6529     }
6530   }
6531   jresult = (void *)result;
6532   return jresult;
6533 }
6534
6535
6536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
6537   void * jresult ;
6538   float *arg1 = (float *) 0 ;
6539   Dali::Vector4 *result = 0 ;
6540
6541   arg1 = jarg1;
6542   {
6543     try {
6544       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
6545     } catch (std::out_of_range& e) {
6546       {
6547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6548       };
6549     } catch (std::exception& e) {
6550       {
6551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6552       };
6553     } catch (...) {
6554       {
6555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6556       };
6557     }
6558   }
6559   jresult = (void *)result;
6560
6561
6562   return jresult;
6563 }
6564
6565
6566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
6567   void * jresult ;
6568   Dali::Vector2 *arg1 = 0 ;
6569   Dali::Vector4 *result = 0 ;
6570
6571   arg1 = (Dali::Vector2 *)jarg1;
6572   if (!arg1) {
6573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6574     return 0;
6575   }
6576   {
6577     try {
6578       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
6579     } catch (std::out_of_range& e) {
6580       {
6581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6582       };
6583     } catch (std::exception& e) {
6584       {
6585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6586       };
6587     } catch (...) {
6588       {
6589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6590       };
6591     }
6592   }
6593   jresult = (void *)result;
6594   return jresult;
6595 }
6596
6597
6598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
6599   void * jresult ;
6600   Dali::Vector3 *arg1 = 0 ;
6601   Dali::Vector4 *result = 0 ;
6602
6603   arg1 = (Dali::Vector3 *)jarg1;
6604   if (!arg1) {
6605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6606     return 0;
6607   }
6608   {
6609     try {
6610       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
6611     } catch (std::out_of_range& e) {
6612       {
6613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6614       };
6615     } catch (std::exception& e) {
6616       {
6617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6618       };
6619     } catch (...) {
6620       {
6621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6622       };
6623     }
6624   }
6625   jresult = (void *)result;
6626   return jresult;
6627 }
6628
6629
6630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
6631   void * jresult ;
6632   Dali::Vector4 *result = 0 ;
6633
6634   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
6635   jresult = (void *)result;
6636   return jresult;
6637 }
6638
6639
6640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
6641   void * jresult ;
6642   Dali::Vector4 *result = 0 ;
6643
6644   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
6645   jresult = (void *)result;
6646   return jresult;
6647 }
6648
6649
6650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
6651   void * jresult ;
6652   Dali::Vector4 *result = 0 ;
6653
6654   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
6655   jresult = (void *)result;
6656   return jresult;
6657 }
6658
6659
6660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
6661   void * jresult ;
6662   Dali::Vector4 *result = 0 ;
6663
6664   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
6665   jresult = (void *)result;
6666   return jresult;
6667 }
6668
6669
6670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
6671   void * jresult ;
6672   Dali::Vector4 *result = 0 ;
6673
6674   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
6675   jresult = (void *)result;
6676   return jresult;
6677 }
6678
6679
6680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
6681   void * jresult ;
6682   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6683   float *arg2 = (float *) 0 ;
6684   Dali::Vector4 *result = 0 ;
6685
6686   arg1 = (Dali::Vector4 *)jarg1;
6687   arg2 = jarg2;
6688   {
6689     try {
6690       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
6691     } catch (std::out_of_range& e) {
6692       {
6693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6694       };
6695     } catch (std::exception& e) {
6696       {
6697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6698       };
6699     } catch (...) {
6700       {
6701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6702       };
6703     }
6704   }
6705   jresult = (void *)result;
6706
6707
6708   return jresult;
6709 }
6710
6711
6712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
6713   void * jresult ;
6714   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6715   Dali::Vector2 *arg2 = 0 ;
6716   Dali::Vector4 *result = 0 ;
6717
6718   arg1 = (Dali::Vector4 *)jarg1;
6719   arg2 = (Dali::Vector2 *)jarg2;
6720   if (!arg2) {
6721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6722     return 0;
6723   }
6724   {
6725     try {
6726       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
6727     } catch (std::out_of_range& e) {
6728       {
6729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6730       };
6731     } catch (std::exception& e) {
6732       {
6733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6734       };
6735     } catch (...) {
6736       {
6737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6738       };
6739     }
6740   }
6741   jresult = (void *)result;
6742   return jresult;
6743 }
6744
6745
6746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
6747   void * jresult ;
6748   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6749   Dali::Vector3 *arg2 = 0 ;
6750   Dali::Vector4 *result = 0 ;
6751
6752   arg1 = (Dali::Vector4 *)jarg1;
6753   arg2 = (Dali::Vector3 *)jarg2;
6754   if (!arg2) {
6755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6756     return 0;
6757   }
6758   {
6759     try {
6760       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
6761     } catch (std::out_of_range& e) {
6762       {
6763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6764       };
6765     } catch (std::exception& e) {
6766       {
6767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6768       };
6769     } catch (...) {
6770       {
6771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6772       };
6773     }
6774   }
6775   jresult = (void *)result;
6776   return jresult;
6777 }
6778
6779
6780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
6781   void * jresult ;
6782   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6783   Dali::Vector4 *arg2 = 0 ;
6784   Dali::Vector4 result;
6785
6786   arg1 = (Dali::Vector4 *)jarg1;
6787   arg2 = (Dali::Vector4 *)jarg2;
6788   if (!arg2) {
6789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6790     return 0;
6791   }
6792   {
6793     try {
6794       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
6795     } catch (std::out_of_range& e) {
6796       {
6797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6798       };
6799     } catch (std::exception& e) {
6800       {
6801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6802       };
6803     } catch (...) {
6804       {
6805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6806       };
6807     }
6808   }
6809   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6810   return jresult;
6811 }
6812
6813
6814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
6815   void * jresult ;
6816   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6817   Dali::Vector4 *arg2 = 0 ;
6818   Dali::Vector4 *result = 0 ;
6819
6820   arg1 = (Dali::Vector4 *)jarg1;
6821   arg2 = (Dali::Vector4 *)jarg2;
6822   if (!arg2) {
6823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6824     return 0;
6825   }
6826   {
6827     try {
6828       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
6829     } catch (std::out_of_range& e) {
6830       {
6831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6832       };
6833     } catch (std::exception& e) {
6834       {
6835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6836       };
6837     } catch (...) {
6838       {
6839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6840       };
6841     }
6842   }
6843   jresult = (void *)result;
6844   return jresult;
6845 }
6846
6847
6848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6849   void * jresult ;
6850   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6851   Dali::Vector4 *arg2 = 0 ;
6852   Dali::Vector4 result;
6853
6854   arg1 = (Dali::Vector4 *)jarg1;
6855   arg2 = (Dali::Vector4 *)jarg2;
6856   if (!arg2) {
6857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6858     return 0;
6859   }
6860   {
6861     try {
6862       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
6863     } catch (std::out_of_range& e) {
6864       {
6865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6866       };
6867     } catch (std::exception& e) {
6868       {
6869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6870       };
6871     } catch (...) {
6872       {
6873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6874       };
6875     }
6876   }
6877   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6878   return jresult;
6879 }
6880
6881
6882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
6883   void * jresult ;
6884   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6885   Dali::Vector4 *arg2 = 0 ;
6886   Dali::Vector4 *result = 0 ;
6887
6888   arg1 = (Dali::Vector4 *)jarg1;
6889   arg2 = (Dali::Vector4 *)jarg2;
6890   if (!arg2) {
6891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6892     return 0;
6893   }
6894   {
6895     try {
6896       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
6897     } catch (std::out_of_range& e) {
6898       {
6899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6900       };
6901     } catch (std::exception& e) {
6902       {
6903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6904       };
6905     } catch (...) {
6906       {
6907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6908       };
6909     }
6910   }
6911   jresult = (void *)result;
6912   return jresult;
6913 }
6914
6915
6916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6917   void * jresult ;
6918   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6919   Dali::Vector4 *arg2 = 0 ;
6920   Dali::Vector4 result;
6921
6922   arg1 = (Dali::Vector4 *)jarg1;
6923   arg2 = (Dali::Vector4 *)jarg2;
6924   if (!arg2) {
6925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6926     return 0;
6927   }
6928   {
6929     try {
6930       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
6931     } catch (std::out_of_range& e) {
6932       {
6933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6934       };
6935     } catch (std::exception& e) {
6936       {
6937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6938       };
6939     } catch (...) {
6940       {
6941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6942       };
6943     }
6944   }
6945   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6946   return jresult;
6947 }
6948
6949
6950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
6951   void * jresult ;
6952   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6953   float arg2 ;
6954   Dali::Vector4 result;
6955
6956   arg1 = (Dali::Vector4 *)jarg1;
6957   arg2 = (float)jarg2;
6958   {
6959     try {
6960       result = ((Dali::Vector4 const *)arg1)->operator *(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_MultiplyAssign__SWIG_0(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_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7015   void * jresult ;
7016   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7017   float arg2 ;
7018   Dali::Vector4 *result = 0 ;
7019
7020   arg1 = (Dali::Vector4 *)jarg1;
7021   arg2 = (float)jarg2;
7022   {
7023     try {
7024       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7025     } catch (std::out_of_range& e) {
7026       {
7027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7028       };
7029     } catch (std::exception& e) {
7030       {
7031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7032       };
7033     } catch (...) {
7034       {
7035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7036       };
7037     }
7038   }
7039   jresult = (void *)result;
7040   return jresult;
7041 }
7042
7043
7044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7045   void * jresult ;
7046   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7047   Dali::Vector4 *arg2 = 0 ;
7048   Dali::Vector4 result;
7049
7050   arg1 = (Dali::Vector4 *)jarg1;
7051   arg2 = (Dali::Vector4 *)jarg2;
7052   if (!arg2) {
7053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7054     return 0;
7055   }
7056   {
7057     try {
7058       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*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_Divide__SWIG_1(void * jarg1, float jarg2) {
7079   void * jresult ;
7080   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7081   float arg2 ;
7082   Dali::Vector4 result;
7083
7084   arg1 = (Dali::Vector4 *)jarg1;
7085   arg2 = (float)jarg2;
7086   {
7087     try {
7088       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7089     } catch (std::out_of_range& e) {
7090       {
7091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7092       };
7093     } catch (std::exception& e) {
7094       {
7095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7096       };
7097     } catch (...) {
7098       {
7099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7100       };
7101     }
7102   }
7103   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7104   return jresult;
7105 }
7106
7107
7108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7109   void * jresult ;
7110   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7111   Dali::Vector4 *arg2 = 0 ;
7112   Dali::Vector4 *result = 0 ;
7113
7114   arg1 = (Dali::Vector4 *)jarg1;
7115   arg2 = (Dali::Vector4 *)jarg2;
7116   if (!arg2) {
7117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7118     return 0;
7119   }
7120   {
7121     try {
7122       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*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_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
7143   void * jresult ;
7144   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7145   float arg2 ;
7146   Dali::Vector4 *result = 0 ;
7147
7148   arg1 = (Dali::Vector4 *)jarg1;
7149   arg2 = (float)jarg2;
7150   {
7151     try {
7152       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
7153     } catch (std::out_of_range& e) {
7154       {
7155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7156       };
7157     } catch (std::exception& e) {
7158       {
7159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7160       };
7161     } catch (...) {
7162       {
7163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7164       };
7165     }
7166   }
7167   jresult = (void *)result;
7168   return jresult;
7169 }
7170
7171
7172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
7173   void * jresult ;
7174   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7175   Dali::Vector4 result;
7176
7177   arg1 = (Dali::Vector4 *)jarg1;
7178   {
7179     try {
7180       result = ((Dali::Vector4 const *)arg1)->operator -();
7181     } catch (std::out_of_range& e) {
7182       {
7183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7184       };
7185     } catch (std::exception& e) {
7186       {
7187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7188       };
7189     } catch (...) {
7190       {
7191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7192       };
7193     }
7194   }
7195   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7196   return jresult;
7197 }
7198
7199
7200 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
7201   unsigned int jresult ;
7202   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7203   Dali::Vector4 *arg2 = 0 ;
7204   bool result;
7205
7206   arg1 = (Dali::Vector4 *)jarg1;
7207   arg2 = (Dali::Vector4 *)jarg2;
7208   if (!arg2) {
7209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7210     return 0;
7211   }
7212   {
7213     try {
7214       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
7215     } catch (std::out_of_range& e) {
7216       {
7217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7218       };
7219     } catch (std::exception& e) {
7220       {
7221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7222       };
7223     } catch (...) {
7224       {
7225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7226       };
7227     }
7228   }
7229   jresult = result;
7230   return jresult;
7231 }
7232
7233
7234 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
7235   unsigned int jresult ;
7236   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7237   Dali::Vector4 *arg2 = 0 ;
7238   bool result;
7239
7240   arg1 = (Dali::Vector4 *)jarg1;
7241   arg2 = (Dali::Vector4 *)jarg2;
7242   if (!arg2) {
7243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7244     return 0;
7245   }
7246   {
7247     try {
7248       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
7249     } catch (std::out_of_range& e) {
7250       {
7251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7252       };
7253     } catch (std::exception& e) {
7254       {
7255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7256       };
7257     } catch (...) {
7258       {
7259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7260       };
7261     }
7262   }
7263   jresult = result;
7264   return jresult;
7265 }
7266
7267
7268 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
7269   float jresult ;
7270   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7271   unsigned int arg2 ;
7272   float *result = 0 ;
7273
7274   arg1 = (Dali::Vector4 *)jarg1;
7275   arg2 = (unsigned int)jarg2;
7276   {
7277     try {
7278       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
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 = *result;
7294   return jresult;
7295 }
7296
7297
7298 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
7299   float jresult ;
7300   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7301   Dali::Vector3 *arg2 = 0 ;
7302   float result;
7303
7304   arg1 = (Dali::Vector4 *)jarg1;
7305   arg2 = (Dali::Vector3 *)jarg2;
7306   if (!arg2) {
7307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7308     return 0;
7309   }
7310   {
7311     try {
7312       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 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 float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
7333   float jresult ;
7334   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7335   Dali::Vector4 *arg2 = 0 ;
7336   float 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 = (float)((Dali::Vector4 const *)arg1)->Dot((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_Dot4(void * jarg1, void * jarg2) {
7367   float jresult ;
7368   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7369   Dali::Vector4 *arg2 = 0 ;
7370   float result;
7371
7372   arg1 = (Dali::Vector4 *)jarg1;
7373   arg2 = (Dali::Vector4 *)jarg2;
7374   if (!arg2) {
7375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7376     return 0;
7377   }
7378   {
7379     try {
7380       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
7381     } catch (std::out_of_range& e) {
7382       {
7383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7384       };
7385     } catch (std::exception& e) {
7386       {
7387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7388       };
7389     } catch (...) {
7390       {
7391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7392       };
7393     }
7394   }
7395   jresult = result;
7396   return jresult;
7397 }
7398
7399
7400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
7401   void * jresult ;
7402   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7403   Dali::Vector4 *arg2 = 0 ;
7404   Dali::Vector4 result;
7405
7406   arg1 = (Dali::Vector4 *)jarg1;
7407   arg2 = (Dali::Vector4 *)jarg2;
7408   if (!arg2) {
7409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7410     return 0;
7411   }
7412   {
7413     try {
7414       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
7415     } catch (std::out_of_range& e) {
7416       {
7417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7418       };
7419     } catch (std::exception& e) {
7420       {
7421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7422       };
7423     } catch (...) {
7424       {
7425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7426       };
7427     }
7428   }
7429   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7430   return jresult;
7431 }
7432
7433
7434 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
7435   float jresult ;
7436   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7437   float result;
7438
7439   arg1 = (Dali::Vector4 *)jarg1;
7440   {
7441     try {
7442       result = (float)((Dali::Vector4 const *)arg1)->Length();
7443     } catch (std::out_of_range& e) {
7444       {
7445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7446       };
7447     } catch (std::exception& e) {
7448       {
7449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7450       };
7451     } catch (...) {
7452       {
7453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7454       };
7455     }
7456   }
7457   jresult = result;
7458   return jresult;
7459 }
7460
7461
7462 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
7463   float jresult ;
7464   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7465   float result;
7466
7467   arg1 = (Dali::Vector4 *)jarg1;
7468   {
7469     try {
7470       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
7471     } catch (std::out_of_range& e) {
7472       {
7473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7474       };
7475     } catch (std::exception& e) {
7476       {
7477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7478       };
7479     } catch (...) {
7480       {
7481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7482       };
7483     }
7484   }
7485   jresult = result;
7486   return jresult;
7487 }
7488
7489
7490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
7491   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7492
7493   arg1 = (Dali::Vector4 *)jarg1;
7494   {
7495     try {
7496       (arg1)->Normalize();
7497     } catch (std::out_of_range& e) {
7498       {
7499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7500       };
7501     } catch (std::exception& e) {
7502       {
7503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7504       };
7505     } catch (...) {
7506       {
7507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7508       };
7509     }
7510   }
7511 }
7512
7513
7514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
7515   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7516   Dali::Vector4 *arg2 = 0 ;
7517   Dali::Vector4 *arg3 = 0 ;
7518
7519   arg1 = (Dali::Vector4 *)jarg1;
7520   arg2 = (Dali::Vector4 *)jarg2;
7521   if (!arg2) {
7522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7523     return ;
7524   }
7525   arg3 = (Dali::Vector4 *)jarg3;
7526   if (!arg3) {
7527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7528     return ;
7529   }
7530   {
7531     try {
7532       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
7533     } catch (std::out_of_range& e) {
7534       {
7535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7536       };
7537     } catch (std::exception& e) {
7538       {
7539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7540       };
7541     } catch (...) {
7542       {
7543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7544       };
7545     }
7546   }
7547 }
7548
7549
7550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
7551   void * jresult ;
7552   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7553   float *result = 0 ;
7554
7555   arg1 = (Dali::Vector4 *)jarg1;
7556   {
7557     try {
7558       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
7559     } catch (std::out_of_range& e) {
7560       {
7561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7562       };
7563     } catch (std::exception& e) {
7564       {
7565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7566       };
7567     } catch (...) {
7568       {
7569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7570       };
7571     }
7572   }
7573   jresult = (void *)result;
7574   return jresult;
7575 }
7576
7577
7578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
7579   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7580   float arg2 ;
7581
7582   arg1 = (Dali::Vector4 *)jarg1;
7583   arg2 = (float)jarg2;
7584   if (arg1) (arg1)->x = arg2;
7585 }
7586
7587
7588 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
7589   float jresult ;
7590   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7591   float result;
7592
7593   arg1 = (Dali::Vector4 *)jarg1;
7594   result = (float) ((arg1)->x);
7595   jresult = result;
7596   return jresult;
7597 }
7598
7599
7600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
7601   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7602   float arg2 ;
7603
7604   arg1 = (Dali::Vector4 *)jarg1;
7605   arg2 = (float)jarg2;
7606   if (arg1) (arg1)->r = arg2;
7607 }
7608
7609
7610 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
7611   float jresult ;
7612   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7613   float result;
7614
7615   arg1 = (Dali::Vector4 *)jarg1;
7616   result = (float) ((arg1)->r);
7617   jresult = result;
7618   return jresult;
7619 }
7620
7621
7622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
7623   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7624   float arg2 ;
7625
7626   arg1 = (Dali::Vector4 *)jarg1;
7627   arg2 = (float)jarg2;
7628   if (arg1) (arg1)->s = arg2;
7629 }
7630
7631
7632 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
7633   float jresult ;
7634   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7635   float result;
7636
7637   arg1 = (Dali::Vector4 *)jarg1;
7638   result = (float) ((arg1)->s);
7639   jresult = result;
7640   return jresult;
7641 }
7642
7643
7644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
7645   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7646   float arg2 ;
7647
7648   arg1 = (Dali::Vector4 *)jarg1;
7649   arg2 = (float)jarg2;
7650   if (arg1) (arg1)->y = arg2;
7651 }
7652
7653
7654 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
7655   float jresult ;
7656   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7657   float result;
7658
7659   arg1 = (Dali::Vector4 *)jarg1;
7660   result = (float) ((arg1)->y);
7661   jresult = result;
7662   return jresult;
7663 }
7664
7665
7666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
7667   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7668   float arg2 ;
7669
7670   arg1 = (Dali::Vector4 *)jarg1;
7671   arg2 = (float)jarg2;
7672   if (arg1) (arg1)->g = arg2;
7673 }
7674
7675
7676 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
7677   float jresult ;
7678   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7679   float result;
7680
7681   arg1 = (Dali::Vector4 *)jarg1;
7682   result = (float) ((arg1)->g);
7683   jresult = result;
7684   return jresult;
7685 }
7686
7687
7688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
7689   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7690   float arg2 ;
7691
7692   arg1 = (Dali::Vector4 *)jarg1;
7693   arg2 = (float)jarg2;
7694   if (arg1) (arg1)->t = arg2;
7695 }
7696
7697
7698 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
7699   float jresult ;
7700   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7701   float result;
7702
7703   arg1 = (Dali::Vector4 *)jarg1;
7704   result = (float) ((arg1)->t);
7705   jresult = result;
7706   return jresult;
7707 }
7708
7709
7710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
7711   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7712   float arg2 ;
7713
7714   arg1 = (Dali::Vector4 *)jarg1;
7715   arg2 = (float)jarg2;
7716   if (arg1) (arg1)->z = arg2;
7717 }
7718
7719
7720 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
7721   float jresult ;
7722   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7723   float result;
7724
7725   arg1 = (Dali::Vector4 *)jarg1;
7726   result = (float) ((arg1)->z);
7727   jresult = result;
7728   return jresult;
7729 }
7730
7731
7732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
7733   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7734   float arg2 ;
7735
7736   arg1 = (Dali::Vector4 *)jarg1;
7737   arg2 = (float)jarg2;
7738   if (arg1) (arg1)->b = arg2;
7739 }
7740
7741
7742 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
7743   float jresult ;
7744   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7745   float result;
7746
7747   arg1 = (Dali::Vector4 *)jarg1;
7748   result = (float) ((arg1)->b);
7749   jresult = result;
7750   return jresult;
7751 }
7752
7753
7754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
7755   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7756   float arg2 ;
7757
7758   arg1 = (Dali::Vector4 *)jarg1;
7759   arg2 = (float)jarg2;
7760   if (arg1) (arg1)->p = arg2;
7761 }
7762
7763
7764 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
7765   float jresult ;
7766   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7767   float result;
7768
7769   arg1 = (Dali::Vector4 *)jarg1;
7770   result = (float) ((arg1)->p);
7771   jresult = result;
7772   return jresult;
7773 }
7774
7775
7776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
7777   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7778   float arg2 ;
7779
7780   arg1 = (Dali::Vector4 *)jarg1;
7781   arg2 = (float)jarg2;
7782   if (arg1) (arg1)->w = arg2;
7783 }
7784
7785
7786 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
7787   float jresult ;
7788   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7789   float result;
7790
7791   arg1 = (Dali::Vector4 *)jarg1;
7792   result = (float) ((arg1)->w);
7793   jresult = result;
7794   return jresult;
7795 }
7796
7797
7798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
7799   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7800   float arg2 ;
7801
7802   arg1 = (Dali::Vector4 *)jarg1;
7803   arg2 = (float)jarg2;
7804   if (arg1) (arg1)->a = arg2;
7805 }
7806
7807
7808 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
7809   float jresult ;
7810   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7811   float result;
7812
7813   arg1 = (Dali::Vector4 *)jarg1;
7814   result = (float) ((arg1)->a);
7815   jresult = result;
7816   return jresult;
7817 }
7818
7819
7820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
7821   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7822   float arg2 ;
7823
7824   arg1 = (Dali::Vector4 *)jarg1;
7825   arg2 = (float)jarg2;
7826   if (arg1) (arg1)->q = arg2;
7827 }
7828
7829
7830 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
7831   float jresult ;
7832   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7833   float result;
7834
7835   arg1 = (Dali::Vector4 *)jarg1;
7836   result = (float) ((arg1)->q);
7837   jresult = result;
7838   return jresult;
7839 }
7840
7841
7842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
7843   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7844
7845   arg1 = (Dali::Vector4 *)jarg1;
7846   {
7847     try {
7848       delete arg1;
7849     } catch (std::out_of_range& e) {
7850       {
7851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7852       };
7853     } catch (std::exception& e) {
7854       {
7855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7856       };
7857     } catch (...) {
7858       {
7859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7860       };
7861     }
7862   }
7863 }
7864
7865
7866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
7867   void * jresult ;
7868   Dali::Vector4 *arg1 = 0 ;
7869   Dali::Vector4 *arg2 = 0 ;
7870   Dali::Vector4 result;
7871
7872   arg1 = (Dali::Vector4 *)jarg1;
7873   if (!arg1) {
7874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7875     return 0;
7876   }
7877   arg2 = (Dali::Vector4 *)jarg2;
7878   if (!arg2) {
7879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7880     return 0;
7881   }
7882   {
7883     try {
7884       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7885     } catch (std::out_of_range& e) {
7886       {
7887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7888       };
7889     } catch (std::exception& e) {
7890       {
7891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7892       };
7893     } catch (...) {
7894       {
7895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7896       };
7897     }
7898   }
7899   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7900   return jresult;
7901 }
7902
7903
7904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
7905   void * jresult ;
7906   Dali::Vector4 *arg1 = 0 ;
7907   Dali::Vector4 *arg2 = 0 ;
7908   Dali::Vector4 result;
7909
7910   arg1 = (Dali::Vector4 *)jarg1;
7911   if (!arg1) {
7912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7913     return 0;
7914   }
7915   arg2 = (Dali::Vector4 *)jarg2;
7916   if (!arg2) {
7917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7918     return 0;
7919   }
7920   {
7921     try {
7922       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7923     } catch (std::out_of_range& e) {
7924       {
7925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7926       };
7927     } catch (std::exception& e) {
7928       {
7929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7930       };
7931     } catch (...) {
7932       {
7933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7934       };
7935     }
7936   }
7937   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7938   return jresult;
7939 }
7940
7941
7942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
7943   void * jresult ;
7944   Dali::Vector4 *arg1 = 0 ;
7945   float *arg2 = 0 ;
7946   float *arg3 = 0 ;
7947   float temp2 ;
7948   float temp3 ;
7949   Dali::Vector4 result;
7950
7951   arg1 = (Dali::Vector4 *)jarg1;
7952   if (!arg1) {
7953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7954     return 0;
7955   }
7956   temp2 = (float)jarg2;
7957   arg2 = &temp2;
7958   temp3 = (float)jarg3;
7959   arg3 = &temp3;
7960   {
7961     try {
7962       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7963     } catch (std::out_of_range& e) {
7964       {
7965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7966       };
7967     } catch (std::exception& e) {
7968       {
7969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7970       };
7971     } catch (...) {
7972       {
7973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7974       };
7975     }
7976   }
7977   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7978   return jresult;
7979 }
7980
7981
7982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
7983   void * jresult ;
7984   Dali::Uint16Pair *result = 0 ;
7985
7986   {
7987     try {
7988       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
7989     } catch (std::out_of_range& e) {
7990       {
7991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7992       };
7993     } catch (std::exception& e) {
7994       {
7995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7996       };
7997     } catch (...) {
7998       {
7999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8000       };
8001     }
8002   }
8003   jresult = (void *)result;
8004   return jresult;
8005 }
8006
8007
8008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8009   void * jresult ;
8010   uint32_t arg1 ;
8011   uint32_t arg2 ;
8012   Dali::Uint16Pair *result = 0 ;
8013
8014   arg1 = (uint32_t)jarg1;
8015   arg2 = (uint32_t)jarg2;
8016   {
8017     try {
8018       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8019     } catch (std::out_of_range& e) {
8020       {
8021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8022       };
8023     } catch (std::exception& e) {
8024       {
8025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8026       };
8027     } catch (...) {
8028       {
8029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8030       };
8031     }
8032   }
8033   jresult = (void *)result;
8034   return jresult;
8035 }
8036
8037
8038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
8039   void * jresult ;
8040   Dali::Uint16Pair *arg1 = 0 ;
8041   Dali::Uint16Pair *result = 0 ;
8042
8043   arg1 = (Dali::Uint16Pair *)jarg1;
8044   if (!arg1) {
8045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8046     return 0;
8047   }
8048   {
8049     try {
8050       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
8051     } catch (std::out_of_range& e) {
8052       {
8053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8054       };
8055     } catch (std::exception& e) {
8056       {
8057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8058       };
8059     } catch (...) {
8060       {
8061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8062       };
8063     }
8064   }
8065   jresult = (void *)result;
8066   return jresult;
8067 }
8068
8069
8070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
8071   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8072   uint16_t arg2 ;
8073
8074   arg1 = (Dali::Uint16Pair *)jarg1;
8075   arg2 = (uint16_t)jarg2;
8076   {
8077     try {
8078       (arg1)->SetWidth(arg2);
8079     } catch (std::out_of_range& e) {
8080       {
8081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8082       };
8083     } catch (std::exception& e) {
8084       {
8085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8086       };
8087     } catch (...) {
8088       {
8089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8090       };
8091     }
8092   }
8093 }
8094
8095
8096 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
8097   unsigned short jresult ;
8098   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8099   uint16_t result;
8100
8101   arg1 = (Dali::Uint16Pair *)jarg1;
8102   {
8103     try {
8104       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
8105     } catch (std::out_of_range& e) {
8106       {
8107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8108       };
8109     } catch (std::exception& e) {
8110       {
8111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8112       };
8113     } catch (...) {
8114       {
8115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8116       };
8117     }
8118   }
8119   jresult = result;
8120   return jresult;
8121 }
8122
8123
8124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
8125   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8126   uint16_t arg2 ;
8127
8128   arg1 = (Dali::Uint16Pair *)jarg1;
8129   arg2 = (uint16_t)jarg2;
8130   {
8131     try {
8132       (arg1)->SetHeight(arg2);
8133     } catch (std::out_of_range& e) {
8134       {
8135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8136       };
8137     } catch (std::exception& e) {
8138       {
8139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8140       };
8141     } catch (...) {
8142       {
8143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8144       };
8145     }
8146   }
8147 }
8148
8149
8150 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
8151   unsigned short jresult ;
8152   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8153   uint16_t result;
8154
8155   arg1 = (Dali::Uint16Pair *)jarg1;
8156   {
8157     try {
8158       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
8159     } catch (std::out_of_range& e) {
8160       {
8161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8162       };
8163     } catch (std::exception& e) {
8164       {
8165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8166       };
8167     } catch (...) {
8168       {
8169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8170       };
8171     }
8172   }
8173   jresult = result;
8174   return jresult;
8175 }
8176
8177
8178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
8179   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8180   uint16_t arg2 ;
8181
8182   arg1 = (Dali::Uint16Pair *)jarg1;
8183   arg2 = (uint16_t)jarg2;
8184   {
8185     try {
8186       (arg1)->SetX(arg2);
8187     } catch (std::out_of_range& e) {
8188       {
8189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8190       };
8191     } catch (std::exception& e) {
8192       {
8193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8194       };
8195     } catch (...) {
8196       {
8197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8198       };
8199     }
8200   }
8201 }
8202
8203
8204 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
8205   unsigned short jresult ;
8206   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8207   uint16_t result;
8208
8209   arg1 = (Dali::Uint16Pair *)jarg1;
8210   {
8211     try {
8212       result = ((Dali::Uint16Pair const *)arg1)->GetX();
8213     } catch (std::out_of_range& e) {
8214       {
8215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8216       };
8217     } catch (std::exception& e) {
8218       {
8219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8220       };
8221     } catch (...) {
8222       {
8223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8224       };
8225     }
8226   }
8227   jresult = result;
8228   return jresult;
8229 }
8230
8231
8232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
8233   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8234   uint16_t arg2 ;
8235
8236   arg1 = (Dali::Uint16Pair *)jarg1;
8237   arg2 = (uint16_t)jarg2;
8238   {
8239     try {
8240       (arg1)->SetY(arg2);
8241     } catch (std::out_of_range& e) {
8242       {
8243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8244       };
8245     } catch (std::exception& e) {
8246       {
8247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8248       };
8249     } catch (...) {
8250       {
8251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8252       };
8253     }
8254   }
8255 }
8256
8257
8258 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
8259   unsigned short jresult ;
8260   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8261   uint16_t result;
8262
8263   arg1 = (Dali::Uint16Pair *)jarg1;
8264   {
8265     try {
8266       result = ((Dali::Uint16Pair const *)arg1)->GetY();
8267     } catch (std::out_of_range& e) {
8268       {
8269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8270       };
8271     } catch (std::exception& e) {
8272       {
8273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8274       };
8275     } catch (...) {
8276       {
8277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8278       };
8279     }
8280   }
8281   jresult = result;
8282   return jresult;
8283 }
8284
8285
8286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
8287   void * jresult ;
8288   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8289   Dali::Uint16Pair *arg2 = 0 ;
8290   Dali::Uint16Pair *result = 0 ;
8291
8292   arg1 = (Dali::Uint16Pair *)jarg1;
8293   arg2 = (Dali::Uint16Pair *)jarg2;
8294   if (!arg2) {
8295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8296     return 0;
8297   }
8298   {
8299     try {
8300       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
8301     } catch (std::out_of_range& e) {
8302       {
8303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8304       };
8305     } catch (std::exception& e) {
8306       {
8307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8308       };
8309     } catch (...) {
8310       {
8311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8312       };
8313     }
8314   }
8315   jresult = (void *)result;
8316   return jresult;
8317 }
8318
8319
8320 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
8321   unsigned int jresult ;
8322   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8323   Dali::Uint16Pair *arg2 = 0 ;
8324   bool result;
8325
8326   arg1 = (Dali::Uint16Pair *)jarg1;
8327   arg2 = (Dali::Uint16Pair *)jarg2;
8328   if (!arg2) {
8329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8330     return 0;
8331   }
8332   {
8333     try {
8334       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
8335     } catch (std::out_of_range& e) {
8336       {
8337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8338       };
8339     } catch (std::exception& e) {
8340       {
8341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8342       };
8343     } catch (...) {
8344       {
8345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8346       };
8347     }
8348   }
8349   jresult = result;
8350   return jresult;
8351 }
8352
8353
8354 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
8355   unsigned int jresult ;
8356   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8357   Dali::Uint16Pair *arg2 = 0 ;
8358   bool result;
8359
8360   arg1 = (Dali::Uint16Pair *)jarg1;
8361   arg2 = (Dali::Uint16Pair *)jarg2;
8362   if (!arg2) {
8363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8364     return 0;
8365   }
8366   {
8367     try {
8368       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
8369     } catch (std::out_of_range& e) {
8370       {
8371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8372       };
8373     } catch (std::exception& e) {
8374       {
8375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8376       };
8377     } catch (...) {
8378       {
8379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8380       };
8381     }
8382   }
8383   jresult = result;
8384   return jresult;
8385 }
8386
8387
8388 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
8389   unsigned int jresult ;
8390   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8391   Dali::Uint16Pair *arg2 = 0 ;
8392   bool result;
8393
8394   arg1 = (Dali::Uint16Pair *)jarg1;
8395   arg2 = (Dali::Uint16Pair *)jarg2;
8396   if (!arg2) {
8397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8398     return 0;
8399   }
8400   {
8401     try {
8402       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
8403     } catch (std::out_of_range& e) {
8404       {
8405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8406       };
8407     } catch (std::exception& e) {
8408       {
8409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8410       };
8411     } catch (...) {
8412       {
8413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8414       };
8415     }
8416   }
8417   jresult = result;
8418   return jresult;
8419 }
8420
8421
8422 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
8423   unsigned int jresult ;
8424   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8425   Dali::Uint16Pair *arg2 = 0 ;
8426   bool result;
8427
8428   arg1 = (Dali::Uint16Pair *)jarg1;
8429   arg2 = (Dali::Uint16Pair *)jarg2;
8430   if (!arg2) {
8431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8432     return 0;
8433   }
8434   {
8435     try {
8436       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
8437     } catch (std::out_of_range& e) {
8438       {
8439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8440       };
8441     } catch (std::exception& e) {
8442       {
8443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8444       };
8445     } catch (...) {
8446       {
8447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8448       };
8449     }
8450   }
8451   jresult = result;
8452   return jresult;
8453 }
8454
8455
8456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
8457   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8458
8459   arg1 = (Dali::Uint16Pair *)jarg1;
8460   {
8461     try {
8462       delete arg1;
8463     } catch (std::out_of_range& e) {
8464       {
8465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8466       };
8467     } catch (std::exception& e) {
8468       {
8469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8470       };
8471     } catch (...) {
8472       {
8473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8474       };
8475     }
8476   }
8477 }
8478
8479
8480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
8481   void * jresult ;
8482   Dali::Degree *result = 0 ;
8483
8484   {
8485     try {
8486       result = (Dali::Degree *)new Dali::Degree();
8487     } catch (std::out_of_range& e) {
8488       {
8489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8490       };
8491     } catch (std::exception& e) {
8492       {
8493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8494       };
8495     } catch (...) {
8496       {
8497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8498       };
8499     }
8500   }
8501   jresult = (void *)result;
8502   return jresult;
8503 }
8504
8505
8506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
8507   void * jresult ;
8508   float arg1 ;
8509   Dali::Degree *result = 0 ;
8510
8511   arg1 = (float)jarg1;
8512   {
8513     try {
8514       result = (Dali::Degree *)new Dali::Degree(arg1);
8515     } catch (std::out_of_range& e) {
8516       {
8517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8518       };
8519     } catch (std::exception& e) {
8520       {
8521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8522       };
8523     } catch (...) {
8524       {
8525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8526       };
8527     }
8528   }
8529   jresult = (void *)result;
8530   return jresult;
8531 }
8532
8533
8534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
8535   void * jresult ;
8536   Dali::Radian arg1 ;
8537   Dali::Radian *argp1 ;
8538   Dali::Degree *result = 0 ;
8539
8540   argp1 = (Dali::Radian *)jarg1;
8541   if (!argp1) {
8542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8543     return 0;
8544   }
8545   arg1 = *argp1;
8546   {
8547     try {
8548       result = (Dali::Degree *)new Dali::Degree(arg1);
8549     } catch (std::out_of_range& e) {
8550       {
8551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8552       };
8553     } catch (std::exception& e) {
8554       {
8555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8556       };
8557     } catch (...) {
8558       {
8559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8560       };
8561     }
8562   }
8563   jresult = (void *)result;
8564   return jresult;
8565 }
8566
8567
8568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
8569   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8570   float arg2 ;
8571
8572   arg1 = (Dali::Degree *)jarg1;
8573   arg2 = (float)jarg2;
8574   if (arg1) (arg1)->degree = arg2;
8575 }
8576
8577
8578 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
8579   float jresult ;
8580   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8581   float result;
8582
8583   arg1 = (Dali::Degree *)jarg1;
8584   result = (float) ((arg1)->degree);
8585   jresult = result;
8586   return jresult;
8587 }
8588
8589
8590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
8591   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8592
8593   arg1 = (Dali::Degree *)jarg1;
8594   {
8595     try {
8596       delete arg1;
8597     } catch (std::out_of_range& e) {
8598       {
8599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8600       };
8601     } catch (std::exception& e) {
8602       {
8603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8604       };
8605     } catch (...) {
8606       {
8607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8608       };
8609     }
8610   }
8611 }
8612
8613
8614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
8615   void * jresult ;
8616   Dali::Radian *result = 0 ;
8617
8618   result = (Dali::Radian *)&Dali::ANGLE_360;
8619   jresult = (void *)result;
8620   return jresult;
8621 }
8622
8623
8624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
8625   void * jresult ;
8626   Dali::Radian *result = 0 ;
8627
8628   result = (Dali::Radian *)&Dali::ANGLE_315;
8629   jresult = (void *)result;
8630   return jresult;
8631 }
8632
8633
8634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
8635   void * jresult ;
8636   Dali::Radian *result = 0 ;
8637
8638   result = (Dali::Radian *)&Dali::ANGLE_270;
8639   jresult = (void *)result;
8640   return jresult;
8641 }
8642
8643
8644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
8645   void * jresult ;
8646   Dali::Radian *result = 0 ;
8647
8648   result = (Dali::Radian *)&Dali::ANGLE_225;
8649   jresult = (void *)result;
8650   return jresult;
8651 }
8652
8653
8654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
8655   void * jresult ;
8656   Dali::Radian *result = 0 ;
8657
8658   result = (Dali::Radian *)&Dali::ANGLE_180;
8659   jresult = (void *)result;
8660   return jresult;
8661 }
8662
8663
8664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
8665   void * jresult ;
8666   Dali::Radian *result = 0 ;
8667
8668   result = (Dali::Radian *)&Dali::ANGLE_135;
8669   jresult = (void *)result;
8670   return jresult;
8671 }
8672
8673
8674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
8675   void * jresult ;
8676   Dali::Radian *result = 0 ;
8677
8678   result = (Dali::Radian *)&Dali::ANGLE_120;
8679   jresult = (void *)result;
8680   return jresult;
8681 }
8682
8683
8684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
8685   void * jresult ;
8686   Dali::Radian *result = 0 ;
8687
8688   result = (Dali::Radian *)&Dali::ANGLE_90;
8689   jresult = (void *)result;
8690   return jresult;
8691 }
8692
8693
8694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
8695   void * jresult ;
8696   Dali::Radian *result = 0 ;
8697
8698   result = (Dali::Radian *)&Dali::ANGLE_60;
8699   jresult = (void *)result;
8700   return jresult;
8701 }
8702
8703
8704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
8705   void * jresult ;
8706   Dali::Radian *result = 0 ;
8707
8708   result = (Dali::Radian *)&Dali::ANGLE_45;
8709   jresult = (void *)result;
8710   return jresult;
8711 }
8712
8713
8714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
8715   void * jresult ;
8716   Dali::Radian *result = 0 ;
8717
8718   result = (Dali::Radian *)&Dali::ANGLE_30;
8719   jresult = (void *)result;
8720   return jresult;
8721 }
8722
8723
8724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
8725   void * jresult ;
8726   Dali::Radian *result = 0 ;
8727
8728   result = (Dali::Radian *)&Dali::ANGLE_0;
8729   jresult = (void *)result;
8730   return jresult;
8731 }
8732
8733
8734 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
8735   unsigned int jresult ;
8736   Dali::Degree *arg1 = 0 ;
8737   Dali::Degree *arg2 = 0 ;
8738   bool result;
8739
8740   arg1 = (Dali::Degree *)jarg1;
8741   if (!arg1) {
8742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8743     return 0;
8744   }
8745   arg2 = (Dali::Degree *)jarg2;
8746   if (!arg2) {
8747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8748     return 0;
8749   }
8750   {
8751     try {
8752       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8753     } catch (std::out_of_range& e) {
8754       {
8755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8756       };
8757     } catch (std::exception& e) {
8758       {
8759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8760       };
8761     } catch (...) {
8762       {
8763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8764       };
8765     }
8766   }
8767   jresult = result;
8768   return jresult;
8769 }
8770
8771
8772 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
8773   unsigned int jresult ;
8774   Dali::Degree *arg1 = 0 ;
8775   Dali::Degree *arg2 = 0 ;
8776   bool result;
8777
8778   arg1 = (Dali::Degree *)jarg1;
8779   if (!arg1) {
8780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8781     return 0;
8782   }
8783   arg2 = (Dali::Degree *)jarg2;
8784   if (!arg2) {
8785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8786     return 0;
8787   }
8788   {
8789     try {
8790       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8791     } catch (std::out_of_range& e) {
8792       {
8793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8794       };
8795     } catch (std::exception& e) {
8796       {
8797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8798       };
8799     } catch (...) {
8800       {
8801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8802       };
8803     }
8804   }
8805   jresult = result;
8806   return jresult;
8807 }
8808
8809
8810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
8811   void * jresult ;
8812   Dali::Degree arg1 ;
8813   float arg2 ;
8814   float arg3 ;
8815   Dali::Degree *argp1 ;
8816   Dali::Degree result;
8817
8818   argp1 = (Dali::Degree *)jarg1;
8819   if (!argp1) {
8820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8821     return 0;
8822   }
8823   arg1 = *argp1;
8824   arg2 = (float)jarg2;
8825   arg3 = (float)jarg3;
8826   {
8827     try {
8828       result = Dali::Clamp(arg1,arg2,arg3);
8829     } catch (std::out_of_range& e) {
8830       {
8831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8832       };
8833     } catch (std::exception& e) {
8834       {
8835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8836       };
8837     } catch (...) {
8838       {
8839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8840       };
8841     }
8842   }
8843   jresult = new Dali::Degree((const Dali::Degree &)result);
8844   return jresult;
8845 }
8846
8847
8848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
8849   void * jresult ;
8850   Dali::Radian *result = 0 ;
8851
8852   {
8853     try {
8854       result = (Dali::Radian *)new Dali::Radian();
8855     } catch (std::out_of_range& e) {
8856       {
8857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8858       };
8859     } catch (std::exception& e) {
8860       {
8861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8862       };
8863     } catch (...) {
8864       {
8865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8866       };
8867     }
8868   }
8869   jresult = (void *)result;
8870   return jresult;
8871 }
8872
8873
8874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
8875   void * jresult ;
8876   float arg1 ;
8877   Dali::Radian *result = 0 ;
8878
8879   arg1 = (float)jarg1;
8880   {
8881     try {
8882       result = (Dali::Radian *)new Dali::Radian(arg1);
8883     } catch (std::out_of_range& e) {
8884       {
8885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8886       };
8887     } catch (std::exception& e) {
8888       {
8889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8890       };
8891     } catch (...) {
8892       {
8893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8894       };
8895     }
8896   }
8897   jresult = (void *)result;
8898   return jresult;
8899 }
8900
8901
8902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
8903   void * jresult ;
8904   Dali::Degree arg1 ;
8905   Dali::Degree *argp1 ;
8906   Dali::Radian *result = 0 ;
8907
8908   argp1 = (Dali::Degree *)jarg1;
8909   if (!argp1) {
8910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8911     return 0;
8912   }
8913   arg1 = *argp1;
8914   {
8915     try {
8916       result = (Dali::Radian *)new Dali::Radian(arg1);
8917     } catch (std::out_of_range& e) {
8918       {
8919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8920       };
8921     } catch (std::exception& e) {
8922       {
8923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8924       };
8925     } catch (...) {
8926       {
8927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8928       };
8929     }
8930   }
8931   jresult = (void *)result;
8932   return jresult;
8933 }
8934
8935
8936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
8937   void * jresult ;
8938   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8939   float arg2 ;
8940   Dali::Radian *result = 0 ;
8941
8942   arg1 = (Dali::Radian *)jarg1;
8943   arg2 = (float)jarg2;
8944   {
8945     try {
8946       result = (Dali::Radian *) &(arg1)->operator =(arg2);
8947     } catch (std::out_of_range& e) {
8948       {
8949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8950       };
8951     } catch (std::exception& e) {
8952       {
8953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8954       };
8955     } catch (...) {
8956       {
8957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8958       };
8959     }
8960   }
8961   jresult = (void *)result;
8962   return jresult;
8963 }
8964
8965
8966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
8967   void * jresult ;
8968   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8969   Dali::Degree arg2 ;
8970   Dali::Degree *argp2 ;
8971   Dali::Radian *result = 0 ;
8972
8973   arg1 = (Dali::Radian *)jarg1;
8974   argp2 = (Dali::Degree *)jarg2;
8975   if (!argp2) {
8976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8977     return 0;
8978   }
8979   arg2 = *argp2;
8980   {
8981     try {
8982       result = (Dali::Radian *) &(arg1)->operator =(arg2);
8983     } catch (std::out_of_range& e) {
8984       {
8985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8986       };
8987     } catch (std::exception& e) {
8988       {
8989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8990       };
8991     } catch (...) {
8992       {
8993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8994       };
8995     }
8996   }
8997   jresult = (void *)result;
8998   return jresult;
8999 }
9000
9001
9002 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
9003   float jresult ;
9004   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9005   float result;
9006
9007   arg1 = (Dali::Radian *)jarg1;
9008   {
9009     try {
9010       result = (float)((Dali::Radian const *)arg1)->operator float();
9011     } catch (std::out_of_range& e) {
9012       {
9013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9014       };
9015     } catch (std::exception& e) {
9016       {
9017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9018       };
9019     } catch (...) {
9020       {
9021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9022       };
9023     }
9024   }
9025   jresult = result;
9026   return jresult;
9027 }
9028
9029
9030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
9031   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9032   float arg2 ;
9033
9034   arg1 = (Dali::Radian *)jarg1;
9035   arg2 = (float)jarg2;
9036   if (arg1) (arg1)->radian = arg2;
9037 }
9038
9039
9040 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
9041   float jresult ;
9042   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9043   float result;
9044
9045   arg1 = (Dali::Radian *)jarg1;
9046   result = (float) ((arg1)->radian);
9047   jresult = result;
9048   return jresult;
9049 }
9050
9051
9052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
9053   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9054
9055   arg1 = (Dali::Radian *)jarg1;
9056   {
9057     try {
9058       delete arg1;
9059     } catch (std::out_of_range& e) {
9060       {
9061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9062       };
9063     } catch (std::exception& e) {
9064       {
9065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9066       };
9067     } catch (...) {
9068       {
9069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9070       };
9071     }
9072   }
9073 }
9074
9075
9076 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
9077   unsigned int jresult ;
9078   Dali::Radian arg1 ;
9079   Dali::Radian arg2 ;
9080   Dali::Radian *argp1 ;
9081   Dali::Radian *argp2 ;
9082   bool result;
9083
9084   argp1 = (Dali::Radian *)jarg1;
9085   if (!argp1) {
9086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9087     return 0;
9088   }
9089   arg1 = *argp1;
9090   argp2 = (Dali::Radian *)jarg2;
9091   if (!argp2) {
9092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9093     return 0;
9094   }
9095   arg2 = *argp2;
9096   {
9097     try {
9098       result = (bool)Dali::operator ==(arg1,arg2);
9099     } catch (std::out_of_range& e) {
9100       {
9101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9102       };
9103     } catch (std::exception& e) {
9104       {
9105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9106       };
9107     } catch (...) {
9108       {
9109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9110       };
9111     }
9112   }
9113   jresult = result;
9114   return jresult;
9115 }
9116
9117
9118 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
9119   unsigned int jresult ;
9120   Dali::Radian arg1 ;
9121   Dali::Radian arg2 ;
9122   Dali::Radian *argp1 ;
9123   Dali::Radian *argp2 ;
9124   bool result;
9125
9126   argp1 = (Dali::Radian *)jarg1;
9127   if (!argp1) {
9128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9129     return 0;
9130   }
9131   arg1 = *argp1;
9132   argp2 = (Dali::Radian *)jarg2;
9133   if (!argp2) {
9134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9135     return 0;
9136   }
9137   arg2 = *argp2;
9138   {
9139     try {
9140       result = (bool)Dali::operator !=(arg1,arg2);
9141     } catch (std::out_of_range& e) {
9142       {
9143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9144       };
9145     } catch (std::exception& e) {
9146       {
9147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9148       };
9149     } catch (...) {
9150       {
9151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9152       };
9153     }
9154   }
9155   jresult = result;
9156   return jresult;
9157 }
9158
9159
9160 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
9161   unsigned int jresult ;
9162   Dali::Radian arg1 ;
9163   Dali::Degree arg2 ;
9164   Dali::Radian *argp1 ;
9165   Dali::Degree *argp2 ;
9166   bool result;
9167
9168   argp1 = (Dali::Radian *)jarg1;
9169   if (!argp1) {
9170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9171     return 0;
9172   }
9173   arg1 = *argp1;
9174   argp2 = (Dali::Degree *)jarg2;
9175   if (!argp2) {
9176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9177     return 0;
9178   }
9179   arg2 = *argp2;
9180   {
9181     try {
9182       result = (bool)Dali::operator ==(arg1,arg2);
9183     } catch (std::out_of_range& e) {
9184       {
9185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9186       };
9187     } catch (std::exception& e) {
9188       {
9189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9190       };
9191     } catch (...) {
9192       {
9193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9194       };
9195     }
9196   }
9197   jresult = result;
9198   return jresult;
9199 }
9200
9201
9202 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
9203   unsigned int jresult ;
9204   Dali::Radian arg1 ;
9205   Dali::Degree arg2 ;
9206   Dali::Radian *argp1 ;
9207   Dali::Degree *argp2 ;
9208   bool result;
9209
9210   argp1 = (Dali::Radian *)jarg1;
9211   if (!argp1) {
9212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9213     return 0;
9214   }
9215   arg1 = *argp1;
9216   argp2 = (Dali::Degree *)jarg2;
9217   if (!argp2) {
9218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9219     return 0;
9220   }
9221   arg2 = *argp2;
9222   {
9223     try {
9224       result = (bool)Dali::operator !=(arg1,arg2);
9225     } catch (std::out_of_range& e) {
9226       {
9227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9228       };
9229     } catch (std::exception& e) {
9230       {
9231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9232       };
9233     } catch (...) {
9234       {
9235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9236       };
9237     }
9238   }
9239   jresult = result;
9240   return jresult;
9241 }
9242
9243
9244 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
9245   unsigned int jresult ;
9246   Dali::Degree arg1 ;
9247   Dali::Radian arg2 ;
9248   Dali::Degree *argp1 ;
9249   Dali::Radian *argp2 ;
9250   bool result;
9251
9252   argp1 = (Dali::Degree *)jarg1;
9253   if (!argp1) {
9254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9255     return 0;
9256   }
9257   arg1 = *argp1;
9258   argp2 = (Dali::Radian *)jarg2;
9259   if (!argp2) {
9260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9261     return 0;
9262   }
9263   arg2 = *argp2;
9264   {
9265     try {
9266       result = (bool)Dali::operator ==(arg1,arg2);
9267     } catch (std::out_of_range& e) {
9268       {
9269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9270       };
9271     } catch (std::exception& e) {
9272       {
9273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9274       };
9275     } catch (...) {
9276       {
9277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9278       };
9279     }
9280   }
9281   jresult = result;
9282   return jresult;
9283 }
9284
9285
9286 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
9287   unsigned int jresult ;
9288   Dali::Degree arg1 ;
9289   Dali::Radian arg2 ;
9290   Dali::Degree *argp1 ;
9291   Dali::Radian *argp2 ;
9292   bool result;
9293
9294   argp1 = (Dali::Degree *)jarg1;
9295   if (!argp1) {
9296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9297     return 0;
9298   }
9299   arg1 = *argp1;
9300   argp2 = (Dali::Radian *)jarg2;
9301   if (!argp2) {
9302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9303     return 0;
9304   }
9305   arg2 = *argp2;
9306   {
9307     try {
9308       result = (bool)Dali::operator !=(arg1,arg2);
9309     } catch (std::out_of_range& e) {
9310       {
9311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9312       };
9313     } catch (std::exception& e) {
9314       {
9315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9316       };
9317     } catch (...) {
9318       {
9319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9320       };
9321     }
9322   }
9323   jresult = result;
9324   return jresult;
9325 }
9326
9327
9328 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
9329   unsigned int jresult ;
9330   Dali::Radian arg1 ;
9331   Dali::Radian arg2 ;
9332   Dali::Radian *argp1 ;
9333   Dali::Radian *argp2 ;
9334   bool result;
9335
9336   argp1 = (Dali::Radian *)jarg1;
9337   if (!argp1) {
9338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9339     return 0;
9340   }
9341   arg1 = *argp1;
9342   argp2 = (Dali::Radian *)jarg2;
9343   if (!argp2) {
9344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9345     return 0;
9346   }
9347   arg2 = *argp2;
9348   {
9349     try {
9350       result = (bool)Dali::operator >(arg1,arg2);
9351     } catch (std::out_of_range& e) {
9352       {
9353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9354       };
9355     } catch (std::exception& e) {
9356       {
9357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9358       };
9359     } catch (...) {
9360       {
9361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9362       };
9363     }
9364   }
9365   jresult = result;
9366   return jresult;
9367 }
9368
9369
9370 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
9371   unsigned int jresult ;
9372   Dali::Radian arg1 ;
9373   Dali::Degree arg2 ;
9374   Dali::Radian *argp1 ;
9375   Dali::Degree *argp2 ;
9376   bool result;
9377
9378   argp1 = (Dali::Radian *)jarg1;
9379   if (!argp1) {
9380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9381     return 0;
9382   }
9383   arg1 = *argp1;
9384   argp2 = (Dali::Degree *)jarg2;
9385   if (!argp2) {
9386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9387     return 0;
9388   }
9389   arg2 = *argp2;
9390   {
9391     try {
9392       result = (bool)Dali::operator >(arg1,arg2);
9393     } catch (std::out_of_range& e) {
9394       {
9395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9396       };
9397     } catch (std::exception& e) {
9398       {
9399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9400       };
9401     } catch (...) {
9402       {
9403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9404       };
9405     }
9406   }
9407   jresult = result;
9408   return jresult;
9409 }
9410
9411
9412 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
9413   unsigned int jresult ;
9414   Dali::Degree arg1 ;
9415   Dali::Radian arg2 ;
9416   Dali::Degree *argp1 ;
9417   Dali::Radian *argp2 ;
9418   bool result;
9419
9420   argp1 = (Dali::Degree *)jarg1;
9421   if (!argp1) {
9422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9423     return 0;
9424   }
9425   arg1 = *argp1;
9426   argp2 = (Dali::Radian *)jarg2;
9427   if (!argp2) {
9428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9429     return 0;
9430   }
9431   arg2 = *argp2;
9432   {
9433     try {
9434       result = (bool)Dali::operator >(arg1,arg2);
9435     } catch (std::out_of_range& e) {
9436       {
9437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9438       };
9439     } catch (std::exception& e) {
9440       {
9441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9442       };
9443     } catch (...) {
9444       {
9445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9446       };
9447     }
9448   }
9449   jresult = result;
9450   return jresult;
9451 }
9452
9453
9454 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
9455   unsigned int jresult ;
9456   Dali::Radian arg1 ;
9457   Dali::Radian arg2 ;
9458   Dali::Radian *argp1 ;
9459   Dali::Radian *argp2 ;
9460   bool result;
9461
9462   argp1 = (Dali::Radian *)jarg1;
9463   if (!argp1) {
9464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9465     return 0;
9466   }
9467   arg1 = *argp1;
9468   argp2 = (Dali::Radian *)jarg2;
9469   if (!argp2) {
9470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9471     return 0;
9472   }
9473   arg2 = *argp2;
9474   {
9475     try {
9476       result = (bool)Dali::operator <(arg1,arg2);
9477     } catch (std::out_of_range& e) {
9478       {
9479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9480       };
9481     } catch (std::exception& e) {
9482       {
9483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9484       };
9485     } catch (...) {
9486       {
9487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9488       };
9489     }
9490   }
9491   jresult = result;
9492   return jresult;
9493 }
9494
9495
9496 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
9497   unsigned int jresult ;
9498   Dali::Radian arg1 ;
9499   Dali::Degree arg2 ;
9500   Dali::Radian *argp1 ;
9501   Dali::Degree *argp2 ;
9502   bool result;
9503
9504   argp1 = (Dali::Radian *)jarg1;
9505   if (!argp1) {
9506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9507     return 0;
9508   }
9509   arg1 = *argp1;
9510   argp2 = (Dali::Degree *)jarg2;
9511   if (!argp2) {
9512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9513     return 0;
9514   }
9515   arg2 = *argp2;
9516   {
9517     try {
9518       result = (bool)Dali::operator <(arg1,arg2);
9519     } catch (std::out_of_range& e) {
9520       {
9521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9522       };
9523     } catch (std::exception& e) {
9524       {
9525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9526       };
9527     } catch (...) {
9528       {
9529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9530       };
9531     }
9532   }
9533   jresult = result;
9534   return jresult;
9535 }
9536
9537
9538 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
9539   unsigned int jresult ;
9540   Dali::Degree arg1 ;
9541   Dali::Radian arg2 ;
9542   Dali::Degree *argp1 ;
9543   Dali::Radian *argp2 ;
9544   bool result;
9545
9546   argp1 = (Dali::Degree *)jarg1;
9547   if (!argp1) {
9548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9549     return 0;
9550   }
9551   arg1 = *argp1;
9552   argp2 = (Dali::Radian *)jarg2;
9553   if (!argp2) {
9554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9555     return 0;
9556   }
9557   arg2 = *argp2;
9558   {
9559     try {
9560       result = (bool)Dali::operator <(arg1,arg2);
9561     } catch (std::out_of_range& e) {
9562       {
9563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9564       };
9565     } catch (std::exception& e) {
9566       {
9567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9568       };
9569     } catch (...) {
9570       {
9571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9572       };
9573     }
9574   }
9575   jresult = result;
9576   return jresult;
9577 }
9578
9579
9580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
9581   void * jresult ;
9582   Dali::Radian arg1 ;
9583   float arg2 ;
9584   Dali::Radian *argp1 ;
9585   Dali::Radian result;
9586
9587   argp1 = (Dali::Radian *)jarg1;
9588   if (!argp1) {
9589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9590     return 0;
9591   }
9592   arg1 = *argp1;
9593   arg2 = (float)jarg2;
9594   {
9595     try {
9596       result = Dali::operator *(arg1,arg2);
9597     } catch (std::out_of_range& e) {
9598       {
9599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9600       };
9601     } catch (std::exception& e) {
9602       {
9603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9604       };
9605     } catch (...) {
9606       {
9607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9608       };
9609     }
9610   }
9611   jresult = new Dali::Radian((const Dali::Radian &)result);
9612   return jresult;
9613 }
9614
9615
9616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
9617   void * jresult ;
9618   Dali::Radian arg1 ;
9619   Dali::Radian *argp1 ;
9620   Dali::Radian result;
9621
9622   argp1 = (Dali::Radian *)jarg1;
9623   if (!argp1) {
9624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9625     return 0;
9626   }
9627   arg1 = *argp1;
9628   {
9629     try {
9630       result = Dali::operator -(arg1);
9631     } catch (std::out_of_range& e) {
9632       {
9633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9634       };
9635     } catch (std::exception& e) {
9636       {
9637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9638       };
9639     } catch (...) {
9640       {
9641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9642       };
9643     }
9644   }
9645   jresult = new Dali::Radian((const Dali::Radian &)result);
9646   return jresult;
9647 }
9648
9649
9650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
9651   void * jresult ;
9652   Dali::Radian arg1 ;
9653   float arg2 ;
9654   float arg3 ;
9655   Dali::Radian *argp1 ;
9656   Dali::Radian result;
9657
9658   argp1 = (Dali::Radian *)jarg1;
9659   if (!argp1) {
9660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9661     return 0;
9662   }
9663   arg1 = *argp1;
9664   arg2 = (float)jarg2;
9665   arg3 = (float)jarg3;
9666   {
9667     try {
9668       result = Dali::Clamp(arg1,arg2,arg3);
9669     } catch (std::out_of_range& e) {
9670       {
9671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9672       };
9673     } catch (std::exception& e) {
9674       {
9675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9676       };
9677     } catch (...) {
9678       {
9679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9680       };
9681     }
9682   }
9683   jresult = new Dali::Radian((const Dali::Radian &)result);
9684   return jresult;
9685 }
9686
9687
9688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
9689   void * jresult ;
9690   Dali::Quaternion *result = 0 ;
9691
9692   {
9693     try {
9694       result = (Dali::Quaternion *)new Dali::Quaternion();
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 = (void *)result;
9710   return jresult;
9711 }
9712
9713
9714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
9715   void * jresult ;
9716   Dali::Radian arg1 ;
9717   Dali::Vector3 *arg2 = 0 ;
9718   Dali::Radian *argp1 ;
9719   Dali::Quaternion *result = 0 ;
9720
9721   argp1 = (Dali::Radian *)jarg1;
9722   if (!argp1) {
9723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9724     return 0;
9725   }
9726   arg1 = *argp1;
9727   arg2 = (Dali::Vector3 *)jarg2;
9728   if (!arg2) {
9729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9730     return 0;
9731   }
9732   {
9733     try {
9734       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
9735     } catch (std::out_of_range& e) {
9736       {
9737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9738       };
9739     } catch (std::exception& e) {
9740       {
9741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9742       };
9743     } catch (...) {
9744       {
9745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9746       };
9747     }
9748   }
9749   jresult = (void *)result;
9750   return jresult;
9751 }
9752
9753
9754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
9755   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9756
9757   arg1 = (Dali::Quaternion *)jarg1;
9758   {
9759     try {
9760       delete arg1;
9761     } catch (std::out_of_range& e) {
9762       {
9763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9764       };
9765     } catch (std::exception& e) {
9766       {
9767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9768       };
9769     } catch (...) {
9770       {
9771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9772       };
9773     }
9774   }
9775 }
9776
9777
9778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
9779   void * jresult ;
9780   Dali::Quaternion *result = 0 ;
9781
9782   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
9783   jresult = (void *)result;
9784   return jresult;
9785 }
9786
9787
9788 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
9789   unsigned int jresult ;
9790   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9791   bool result;
9792
9793   arg1 = (Dali::Quaternion *)jarg1;
9794   {
9795     try {
9796       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
9797     } catch (std::out_of_range& e) {
9798       {
9799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9800       };
9801     } catch (std::exception& e) {
9802       {
9803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9804       };
9805     } catch (...) {
9806       {
9807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9808       };
9809     }
9810   }
9811   jresult = result;
9812   return jresult;
9813 }
9814
9815
9816 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
9817   unsigned int jresult ;
9818   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9819   Dali::Vector3 *arg2 = 0 ;
9820   Dali::Radian *arg3 = 0 ;
9821   bool result;
9822
9823   arg1 = (Dali::Quaternion *)jarg1;
9824   arg2 = (Dali::Vector3 *)jarg2;
9825   if (!arg2) {
9826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
9827     return 0;
9828   }
9829   arg3 = (Dali::Radian *)jarg3;
9830   if (!arg3) {
9831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
9832     return 0;
9833   }
9834   {
9835     try {
9836       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
9837     } catch (std::out_of_range& e) {
9838       {
9839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9840       };
9841     } catch (std::exception& e) {
9842       {
9843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9844       };
9845     } catch (...) {
9846       {
9847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9848       };
9849     }
9850   }
9851   jresult = result;
9852   return jresult;
9853 }
9854
9855
9856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
9857   void * jresult ;
9858   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9859   Dali::Quaternion *arg2 = 0 ;
9860   Dali::Quaternion result;
9861
9862   arg1 = (Dali::Quaternion *)jarg1;
9863   arg2 = (Dali::Quaternion *)jarg2;
9864   if (!arg2) {
9865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9866     return 0;
9867   }
9868   {
9869     try {
9870       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
9871     } catch (std::out_of_range& e) {
9872       {
9873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9874       };
9875     } catch (std::exception& e) {
9876       {
9877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9878       };
9879     } catch (...) {
9880       {
9881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9882       };
9883     }
9884   }
9885   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9886   return jresult;
9887 }
9888
9889
9890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
9891   void * jresult ;
9892   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9893   Dali::Quaternion *arg2 = 0 ;
9894   Dali::Quaternion result;
9895
9896   arg1 = (Dali::Quaternion *)jarg1;
9897   arg2 = (Dali::Quaternion *)jarg2;
9898   if (!arg2) {
9899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9900     return 0;
9901   }
9902   {
9903     try {
9904       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
9905     } catch (std::out_of_range& e) {
9906       {
9907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9908       };
9909     } catch (std::exception& e) {
9910       {
9911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9912       };
9913     } catch (...) {
9914       {
9915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9916       };
9917     }
9918   }
9919   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9920   return jresult;
9921 }
9922
9923
9924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
9925   void * jresult ;
9926   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9927   Dali::Quaternion *arg2 = 0 ;
9928   Dali::Quaternion result;
9929
9930   arg1 = (Dali::Quaternion *)jarg1;
9931   arg2 = (Dali::Quaternion *)jarg2;
9932   if (!arg2) {
9933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9934     return 0;
9935   }
9936   {
9937     try {
9938       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
9939     } catch (std::out_of_range& e) {
9940       {
9941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9942       };
9943     } catch (std::exception& e) {
9944       {
9945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9946       };
9947     } catch (...) {
9948       {
9949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9950       };
9951     }
9952   }
9953   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9954   return jresult;
9955 }
9956
9957
9958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
9959   void * jresult ;
9960   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9961   Dali::Vector3 *arg2 = 0 ;
9962   Dali::Vector3 result;
9963
9964   arg1 = (Dali::Quaternion *)jarg1;
9965   arg2 = (Dali::Vector3 *)jarg2;
9966   if (!arg2) {
9967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9968     return 0;
9969   }
9970   {
9971     try {
9972       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
9973     } catch (std::out_of_range& e) {
9974       {
9975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9976       };
9977     } catch (std::exception& e) {
9978       {
9979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9980       };
9981     } catch (...) {
9982       {
9983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9984       };
9985     }
9986   }
9987   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
9988   return jresult;
9989 }
9990
9991
9992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
9993   void * jresult ;
9994   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9995   Dali::Quaternion *arg2 = 0 ;
9996   Dali::Quaternion result;
9997
9998   arg1 = (Dali::Quaternion *)jarg1;
9999   arg2 = (Dali::Quaternion *)jarg2;
10000   if (!arg2) {
10001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10002     return 0;
10003   }
10004   {
10005     try {
10006       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
10007     } catch (std::out_of_range& e) {
10008       {
10009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10010       };
10011     } catch (std::exception& e) {
10012       {
10013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10014       };
10015     } catch (...) {
10016       {
10017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10018       };
10019     }
10020   }
10021   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10022   return jresult;
10023 }
10024
10025
10026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
10027   void * jresult ;
10028   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10029   float arg2 ;
10030   Dali::Quaternion result;
10031
10032   arg1 = (Dali::Quaternion *)jarg1;
10033   arg2 = (float)jarg2;
10034   {
10035     try {
10036       result = ((Dali::Quaternion const *)arg1)->operator *(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_Divide__SWIG_1(void * jarg1, float jarg2) {
10057   void * jresult ;
10058   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10059   float arg2 ;
10060   Dali::Quaternion result;
10061
10062   arg1 = (Dali::Quaternion *)jarg1;
10063   arg2 = (float)jarg2;
10064   {
10065     try {
10066       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
10067     } catch (std::out_of_range& e) {
10068       {
10069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10070       };
10071     } catch (std::exception& e) {
10072       {
10073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10074       };
10075     } catch (...) {
10076       {
10077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10078       };
10079     }
10080   }
10081   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10082   return jresult;
10083 }
10084
10085
10086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
10087   void * jresult ;
10088   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10089   Dali::Quaternion result;
10090
10091   arg1 = (Dali::Quaternion *)jarg1;
10092   {
10093     try {
10094       result = ((Dali::Quaternion const *)arg1)->operator -();
10095     } catch (std::out_of_range& e) {
10096       {
10097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10098       };
10099     } catch (std::exception& e) {
10100       {
10101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10102       };
10103     } catch (...) {
10104       {
10105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10106       };
10107     }
10108   }
10109   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10110   return jresult;
10111 }
10112
10113
10114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
10115   void * jresult ;
10116   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10117   Dali::Quaternion *arg2 = 0 ;
10118   Dali::Quaternion *result = 0 ;
10119
10120   arg1 = (Dali::Quaternion *)jarg1;
10121   arg2 = (Dali::Quaternion *)jarg2;
10122   if (!arg2) {
10123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10124     return 0;
10125   }
10126   {
10127     try {
10128       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
10129     } catch (std::out_of_range& e) {
10130       {
10131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10132       };
10133     } catch (std::exception& e) {
10134       {
10135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10136       };
10137     } catch (...) {
10138       {
10139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10140       };
10141     }
10142   }
10143   jresult = (void *)result;
10144   return jresult;
10145 }
10146
10147
10148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
10149   void * jresult ;
10150   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10151   Dali::Quaternion *arg2 = 0 ;
10152   Dali::Quaternion *result = 0 ;
10153
10154   arg1 = (Dali::Quaternion *)jarg1;
10155   arg2 = (Dali::Quaternion *)jarg2;
10156   if (!arg2) {
10157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10158     return 0;
10159   }
10160   {
10161     try {
10162       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
10163     } catch (std::out_of_range& e) {
10164       {
10165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10166       };
10167     } catch (std::exception& e) {
10168       {
10169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10170       };
10171     } catch (...) {
10172       {
10173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10174       };
10175     }
10176   }
10177   jresult = (void *)result;
10178   return jresult;
10179 }
10180
10181
10182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
10183   void * jresult ;
10184   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10185   Dali::Quaternion *arg2 = 0 ;
10186   Dali::Quaternion *result = 0 ;
10187
10188   arg1 = (Dali::Quaternion *)jarg1;
10189   arg2 = (Dali::Quaternion *)jarg2;
10190   if (!arg2) {
10191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10192     return 0;
10193   }
10194   {
10195     try {
10196       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
10197     } catch (std::out_of_range& e) {
10198       {
10199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10200       };
10201     } catch (std::exception& e) {
10202       {
10203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10204       };
10205     } catch (...) {
10206       {
10207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10208       };
10209     }
10210   }
10211   jresult = (void *)result;
10212   return jresult;
10213 }
10214
10215
10216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
10217   void * jresult ;
10218   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10219   float arg2 ;
10220   Dali::Quaternion *result = 0 ;
10221
10222   arg1 = (Dali::Quaternion *)jarg1;
10223   arg2 = (float)jarg2;
10224   {
10225     try {
10226       result = (Dali::Quaternion *) &(arg1)->operator *=(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_DivideAssign(void * jarg1, float jarg2) {
10247   void * jresult ;
10248   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10249   float arg2 ;
10250   Dali::Quaternion *result = 0 ;
10251
10252   arg1 = (Dali::Quaternion *)jarg1;
10253   arg2 = (float)jarg2;
10254   {
10255     try {
10256       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
10257     } catch (std::out_of_range& e) {
10258       {
10259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10260       };
10261     } catch (std::exception& e) {
10262       {
10263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10264       };
10265     } catch (...) {
10266       {
10267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10268       };
10269     }
10270   }
10271   jresult = (void *)result;
10272   return jresult;
10273 }
10274
10275
10276 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
10277   unsigned int jresult ;
10278   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10279   Dali::Quaternion *arg2 = 0 ;
10280   bool result;
10281
10282   arg1 = (Dali::Quaternion *)jarg1;
10283   arg2 = (Dali::Quaternion *)jarg2;
10284   if (!arg2) {
10285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10286     return 0;
10287   }
10288   {
10289     try {
10290       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
10291     } catch (std::out_of_range& e) {
10292       {
10293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10294       };
10295     } catch (std::exception& e) {
10296       {
10297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10298       };
10299     } catch (...) {
10300       {
10301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10302       };
10303     }
10304   }
10305   jresult = result;
10306   return jresult;
10307 }
10308
10309
10310 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
10311   unsigned int jresult ;
10312   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10313   Dali::Quaternion *arg2 = 0 ;
10314   bool result;
10315
10316   arg1 = (Dali::Quaternion *)jarg1;
10317   arg2 = (Dali::Quaternion *)jarg2;
10318   if (!arg2) {
10319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10320     return 0;
10321   }
10322   {
10323     try {
10324       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*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 = result;
10340   return jresult;
10341 }
10342
10343
10344 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
10345   float jresult ;
10346   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10347   float result;
10348
10349   arg1 = (Dali::Quaternion *)jarg1;
10350   {
10351     try {
10352       result = (float)((Dali::Quaternion const *)arg1)->Length();
10353     } catch (std::out_of_range& e) {
10354       {
10355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10356       };
10357     } catch (std::exception& e) {
10358       {
10359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10360       };
10361     } catch (...) {
10362       {
10363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10364       };
10365     }
10366   }
10367   jresult = result;
10368   return jresult;
10369 }
10370
10371
10372 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
10373   float jresult ;
10374   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10375   float result;
10376
10377   arg1 = (Dali::Quaternion *)jarg1;
10378   {
10379     try {
10380       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
10381     } catch (std::out_of_range& e) {
10382       {
10383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10384       };
10385     } catch (std::exception& e) {
10386       {
10387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10388       };
10389     } catch (...) {
10390       {
10391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10392       };
10393     }
10394   }
10395   jresult = result;
10396   return jresult;
10397 }
10398
10399
10400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
10401   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10402
10403   arg1 = (Dali::Quaternion *)jarg1;
10404   {
10405     try {
10406       (arg1)->Normalize();
10407     } catch (std::out_of_range& e) {
10408       {
10409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10410       };
10411     } catch (std::exception& e) {
10412       {
10413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10414       };
10415     } catch (...) {
10416       {
10417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10418       };
10419     }
10420   }
10421 }
10422
10423
10424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
10425   void * jresult ;
10426   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10427   Dali::Quaternion result;
10428
10429   arg1 = (Dali::Quaternion *)jarg1;
10430   {
10431     try {
10432       result = ((Dali::Quaternion const *)arg1)->Normalized();
10433     } catch (std::out_of_range& e) {
10434       {
10435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10436       };
10437     } catch (std::exception& e) {
10438       {
10439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10440       };
10441     } catch (...) {
10442       {
10443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10444       };
10445     }
10446   }
10447   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10448   return jresult;
10449 }
10450
10451
10452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
10453   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10454
10455   arg1 = (Dali::Quaternion *)jarg1;
10456   {
10457     try {
10458       (arg1)->Conjugate();
10459     } catch (std::out_of_range& e) {
10460       {
10461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10462       };
10463     } catch (std::exception& e) {
10464       {
10465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10466       };
10467     } catch (...) {
10468       {
10469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10470       };
10471     }
10472   }
10473 }
10474
10475
10476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
10477   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10478
10479   arg1 = (Dali::Quaternion *)jarg1;
10480   {
10481     try {
10482       (arg1)->Invert();
10483     } catch (std::out_of_range& e) {
10484       {
10485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10486       };
10487     } catch (std::exception& e) {
10488       {
10489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10490       };
10491     } catch (...) {
10492       {
10493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10494       };
10495     }
10496   }
10497 }
10498
10499
10500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
10501   void * jresult ;
10502   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10503   Dali::Quaternion result;
10504
10505   arg1 = (Dali::Quaternion *)jarg1;
10506   {
10507     try {
10508       result = ((Dali::Quaternion const *)arg1)->Log();
10509     } catch (std::out_of_range& e) {
10510       {
10511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10512       };
10513     } catch (std::exception& e) {
10514       {
10515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10516       };
10517     } catch (...) {
10518       {
10519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10520       };
10521     }
10522   }
10523   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10524   return jresult;
10525 }
10526
10527
10528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
10529   void * jresult ;
10530   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10531   Dali::Quaternion result;
10532
10533   arg1 = (Dali::Quaternion *)jarg1;
10534   {
10535     try {
10536       result = ((Dali::Quaternion const *)arg1)->Exp();
10537     } catch (std::out_of_range& e) {
10538       {
10539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10540       };
10541     } catch (std::exception& e) {
10542       {
10543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10544       };
10545     } catch (...) {
10546       {
10547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10548       };
10549     }
10550   }
10551   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10552   return jresult;
10553 }
10554
10555
10556 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
10557   float jresult ;
10558   Dali::Quaternion *arg1 = 0 ;
10559   Dali::Quaternion *arg2 = 0 ;
10560   float result;
10561
10562   arg1 = (Dali::Quaternion *)jarg1;
10563   if (!arg1) {
10564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10565     return 0;
10566   }
10567   arg2 = (Dali::Quaternion *)jarg2;
10568   if (!arg2) {
10569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10570     return 0;
10571   }
10572   {
10573     try {
10574       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10575     } catch (std::out_of_range& e) {
10576       {
10577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10578       };
10579     } catch (std::exception& e) {
10580       {
10581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10582       };
10583     } catch (...) {
10584       {
10585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10586       };
10587     }
10588   }
10589   jresult = result;
10590   return jresult;
10591 }
10592
10593
10594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
10595   void * jresult ;
10596   Dali::Quaternion *arg1 = 0 ;
10597   Dali::Quaternion *arg2 = 0 ;
10598   float arg3 ;
10599   Dali::Quaternion result;
10600
10601   arg1 = (Dali::Quaternion *)jarg1;
10602   if (!arg1) {
10603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10604     return 0;
10605   }
10606   arg2 = (Dali::Quaternion *)jarg2;
10607   if (!arg2) {
10608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10609     return 0;
10610   }
10611   arg3 = (float)jarg3;
10612   {
10613     try {
10614       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10615     } catch (std::out_of_range& e) {
10616       {
10617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10618       };
10619     } catch (std::exception& e) {
10620       {
10621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10622       };
10623     } catch (...) {
10624       {
10625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10626       };
10627     }
10628   }
10629   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10630   return jresult;
10631 }
10632
10633
10634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
10635   void * jresult ;
10636   Dali::Quaternion *arg1 = 0 ;
10637   Dali::Quaternion *arg2 = 0 ;
10638   float arg3 ;
10639   Dali::Quaternion result;
10640
10641   arg1 = (Dali::Quaternion *)jarg1;
10642   if (!arg1) {
10643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10644     return 0;
10645   }
10646   arg2 = (Dali::Quaternion *)jarg2;
10647   if (!arg2) {
10648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10649     return 0;
10650   }
10651   arg3 = (float)jarg3;
10652   {
10653     try {
10654       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10655     } catch (std::out_of_range& e) {
10656       {
10657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10658       };
10659     } catch (std::exception& e) {
10660       {
10661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10662       };
10663     } catch (...) {
10664       {
10665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10666       };
10667     }
10668   }
10669   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10670   return jresult;
10671 }
10672
10673
10674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
10675   void * jresult ;
10676   Dali::Quaternion *arg1 = 0 ;
10677   Dali::Quaternion *arg2 = 0 ;
10678   float arg3 ;
10679   Dali::Quaternion result;
10680
10681   arg1 = (Dali::Quaternion *)jarg1;
10682   if (!arg1) {
10683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10684     return 0;
10685   }
10686   arg2 = (Dali::Quaternion *)jarg2;
10687   if (!arg2) {
10688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10689     return 0;
10690   }
10691   arg3 = (float)jarg3;
10692   {
10693     try {
10694       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10695     } catch (std::out_of_range& e) {
10696       {
10697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10698       };
10699     } catch (std::exception& e) {
10700       {
10701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10702       };
10703     } catch (...) {
10704       {
10705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10706       };
10707     }
10708   }
10709   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10710   return jresult;
10711 }
10712
10713
10714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
10715   void * jresult ;
10716   Dali::Quaternion *arg1 = 0 ;
10717   Dali::Quaternion *arg2 = 0 ;
10718   Dali::Quaternion *arg3 = 0 ;
10719   Dali::Quaternion *arg4 = 0 ;
10720   float arg5 ;
10721   Dali::Quaternion result;
10722
10723   arg1 = (Dali::Quaternion *)jarg1;
10724   if (!arg1) {
10725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10726     return 0;
10727   }
10728   arg2 = (Dali::Quaternion *)jarg2;
10729   if (!arg2) {
10730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10731     return 0;
10732   }
10733   arg3 = (Dali::Quaternion *)jarg3;
10734   if (!arg3) {
10735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10736     return 0;
10737   }
10738   arg4 = (Dali::Quaternion *)jarg4;
10739   if (!arg4) {
10740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10741     return 0;
10742   }
10743   arg5 = (float)jarg5;
10744   {
10745     try {
10746       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
10747     } catch (std::out_of_range& e) {
10748       {
10749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10750       };
10751     } catch (std::exception& e) {
10752       {
10753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10754       };
10755     } catch (...) {
10756       {
10757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10758       };
10759     }
10760   }
10761   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10762   return jresult;
10763 }
10764
10765
10766 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
10767   float jresult ;
10768   Dali::Quaternion *arg1 = 0 ;
10769   Dali::Quaternion *arg2 = 0 ;
10770   float result;
10771
10772   arg1 = (Dali::Quaternion *)jarg1;
10773   if (!arg1) {
10774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10775     return 0;
10776   }
10777   arg2 = (Dali::Quaternion *)jarg2;
10778   if (!arg2) {
10779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10780     return 0;
10781   }
10782   {
10783     try {
10784       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10785     } catch (std::out_of_range& e) {
10786       {
10787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10788       };
10789     } catch (std::exception& e) {
10790       {
10791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10792       };
10793     } catch (...) {
10794       {
10795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10796       };
10797     }
10798   }
10799   jresult = result;
10800   return jresult;
10801 }
10802
10803
10804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
10805   void * jresult ;
10806   Dali::Matrix *result = 0 ;
10807
10808   {
10809     try {
10810       result = (Dali::Matrix *)new Dali::Matrix();
10811     } catch (std::out_of_range& e) {
10812       {
10813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10814       };
10815     } catch (std::exception& e) {
10816       {
10817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10818       };
10819     } catch (...) {
10820       {
10821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10822       };
10823     }
10824   }
10825   jresult = (void *)result;
10826   return jresult;
10827 }
10828
10829
10830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
10831   void * jresult ;
10832   bool arg1 ;
10833   Dali::Matrix *result = 0 ;
10834
10835   arg1 = jarg1 ? true : false;
10836   {
10837     try {
10838       result = (Dali::Matrix *)new Dali::Matrix(arg1);
10839     } catch (std::out_of_range& e) {
10840       {
10841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10842       };
10843     } catch (std::exception& e) {
10844       {
10845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10846       };
10847     } catch (...) {
10848       {
10849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10850       };
10851     }
10852   }
10853   jresult = (void *)result;
10854   return jresult;
10855 }
10856
10857
10858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
10859   void * jresult ;
10860   float *arg1 = (float *) 0 ;
10861   Dali::Matrix *result = 0 ;
10862
10863   arg1 = jarg1;
10864   {
10865     try {
10866       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
10867     } catch (std::out_of_range& e) {
10868       {
10869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10870       };
10871     } catch (std::exception& e) {
10872       {
10873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10874       };
10875     } catch (...) {
10876       {
10877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10878       };
10879     }
10880   }
10881   jresult = (void *)result;
10882
10883
10884   return jresult;
10885 }
10886
10887
10888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
10889   void * jresult ;
10890   Dali::Quaternion *arg1 = 0 ;
10891   Dali::Matrix *result = 0 ;
10892
10893   arg1 = (Dali::Quaternion *)jarg1;
10894   if (!arg1) {
10895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10896     return 0;
10897   }
10898   {
10899     try {
10900       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
10901     } catch (std::out_of_range& e) {
10902       {
10903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10904       };
10905     } catch (std::exception& e) {
10906       {
10907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10908       };
10909     } catch (...) {
10910       {
10911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10912       };
10913     }
10914   }
10915   jresult = (void *)result;
10916   return jresult;
10917 }
10918
10919
10920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
10921   void * jresult ;
10922   Dali::Matrix *arg1 = 0 ;
10923   Dali::Matrix *result = 0 ;
10924
10925   arg1 = (Dali::Matrix *)jarg1;
10926   if (!arg1) {
10927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
10928     return 0;
10929   }
10930   {
10931     try {
10932       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
10933     } catch (std::out_of_range& e) {
10934       {
10935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10936       };
10937     } catch (std::exception& e) {
10938       {
10939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10940       };
10941     } catch (...) {
10942       {
10943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10944       };
10945     }
10946   }
10947   jresult = (void *)result;
10948   return jresult;
10949 }
10950
10951
10952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
10953   void * jresult ;
10954   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
10955   Dali::Matrix *arg2 = 0 ;
10956   Dali::Matrix *result = 0 ;
10957
10958   arg1 = (Dali::Matrix *)jarg1;
10959   arg2 = (Dali::Matrix *)jarg2;
10960   if (!arg2) {
10961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
10962     return 0;
10963   }
10964   {
10965     try {
10966       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
10967     } catch (std::out_of_range& e) {
10968       {
10969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10970       };
10971     } catch (std::exception& e) {
10972       {
10973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10974       };
10975     } catch (...) {
10976       {
10977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10978       };
10979     }
10980   }
10981   jresult = (void *)result;
10982   return jresult;
10983 }
10984
10985
10986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
10987   void * jresult ;
10988   Dali::Matrix *result = 0 ;
10989
10990   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
10991   jresult = (void *)result;
10992   return jresult;
10993 }
10994
10995
10996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
10997   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
10998
10999   arg1 = (Dali::Matrix *)jarg1;
11000   {
11001     try {
11002       (arg1)->SetIdentity();
11003     } catch (std::out_of_range& e) {
11004       {
11005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11006       };
11007     } catch (std::exception& e) {
11008       {
11009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11010       };
11011     } catch (...) {
11012       {
11013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11014       };
11015     }
11016   }
11017 }
11018
11019
11020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
11021   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11022   Dali::Vector3 *arg2 = 0 ;
11023
11024   arg1 = (Dali::Matrix *)jarg1;
11025   arg2 = (Dali::Vector3 *)jarg2;
11026   if (!arg2) {
11027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11028     return ;
11029   }
11030   {
11031     try {
11032       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
11033     } catch (std::out_of_range& e) {
11034       {
11035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11036       };
11037     } catch (std::exception& e) {
11038       {
11039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11040       };
11041     } catch (...) {
11042       {
11043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11044       };
11045     }
11046   }
11047 }
11048
11049
11050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
11051   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11052   Dali::Matrix *arg2 = 0 ;
11053
11054   arg1 = (Dali::Matrix *)jarg1;
11055   arg2 = (Dali::Matrix *)jarg2;
11056   if (!arg2) {
11057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11058     return ;
11059   }
11060   {
11061     try {
11062       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
11063     } catch (std::out_of_range& e) {
11064       {
11065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11066       };
11067     } catch (std::exception& e) {
11068       {
11069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11070       };
11071     } catch (...) {
11072       {
11073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11074       };
11075     }
11076   }
11077 }
11078
11079
11080 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
11081   unsigned int jresult ;
11082   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11083   bool result;
11084
11085   arg1 = (Dali::Matrix *)jarg1;
11086   {
11087     try {
11088       result = (bool)(arg1)->Invert();
11089     } catch (std::out_of_range& e) {
11090       {
11091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11092       };
11093     } catch (std::exception& e) {
11094       {
11095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11096       };
11097     } catch (...) {
11098       {
11099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11100       };
11101     }
11102   }
11103   jresult = result;
11104   return jresult;
11105 }
11106
11107
11108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
11109   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11110
11111   arg1 = (Dali::Matrix *)jarg1;
11112   {
11113     try {
11114       (arg1)->Transpose();
11115     } catch (std::out_of_range& e) {
11116       {
11117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11118       };
11119     } catch (std::exception& e) {
11120       {
11121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11122       };
11123     } catch (...) {
11124       {
11125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11126       };
11127     }
11128   }
11129 }
11130
11131
11132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
11133   void * jresult ;
11134   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11135   Dali::Vector3 result;
11136
11137   arg1 = (Dali::Matrix *)jarg1;
11138   {
11139     try {
11140       result = ((Dali::Matrix const *)arg1)->GetXAxis();
11141     } catch (std::out_of_range& e) {
11142       {
11143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11144       };
11145     } catch (std::exception& e) {
11146       {
11147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11148       };
11149     } catch (...) {
11150       {
11151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11152       };
11153     }
11154   }
11155   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11156   return jresult;
11157 }
11158
11159
11160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
11161   void * jresult ;
11162   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11163   Dali::Vector3 result;
11164
11165   arg1 = (Dali::Matrix *)jarg1;
11166   {
11167     try {
11168       result = ((Dali::Matrix const *)arg1)->GetYAxis();
11169     } catch (std::out_of_range& e) {
11170       {
11171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11172       };
11173     } catch (std::exception& e) {
11174       {
11175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11176       };
11177     } catch (...) {
11178       {
11179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11180       };
11181     }
11182   }
11183   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11184   return jresult;
11185 }
11186
11187
11188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
11189   void * jresult ;
11190   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11191   Dali::Vector3 result;
11192
11193   arg1 = (Dali::Matrix *)jarg1;
11194   {
11195     try {
11196       result = ((Dali::Matrix const *)arg1)->GetZAxis();
11197     } catch (std::out_of_range& e) {
11198       {
11199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11200       };
11201     } catch (std::exception& e) {
11202       {
11203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11204       };
11205     } catch (...) {
11206       {
11207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11208       };
11209     }
11210   }
11211   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11212   return jresult;
11213 }
11214
11215
11216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
11217   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11218   Dali::Vector3 *arg2 = 0 ;
11219
11220   arg1 = (Dali::Matrix *)jarg1;
11221   arg2 = (Dali::Vector3 *)jarg2;
11222   if (!arg2) {
11223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11224     return ;
11225   }
11226   {
11227     try {
11228       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
11229     } catch (std::out_of_range& e) {
11230       {
11231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11232       };
11233     } catch (std::exception& e) {
11234       {
11235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11236       };
11237     } catch (...) {
11238       {
11239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11240       };
11241     }
11242   }
11243 }
11244
11245
11246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
11247   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11248   Dali::Vector3 *arg2 = 0 ;
11249
11250   arg1 = (Dali::Matrix *)jarg1;
11251   arg2 = (Dali::Vector3 *)jarg2;
11252   if (!arg2) {
11253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11254     return ;
11255   }
11256   {
11257     try {
11258       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
11259     } catch (std::out_of_range& e) {
11260       {
11261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11262       };
11263     } catch (std::exception& e) {
11264       {
11265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11266       };
11267     } catch (...) {
11268       {
11269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11270       };
11271     }
11272   }
11273 }
11274
11275
11276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
11277   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11278   Dali::Vector3 *arg2 = 0 ;
11279
11280   arg1 = (Dali::Matrix *)jarg1;
11281   arg2 = (Dali::Vector3 *)jarg2;
11282   if (!arg2) {
11283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11284     return ;
11285   }
11286   {
11287     try {
11288       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
11289     } catch (std::out_of_range& e) {
11290       {
11291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11292       };
11293     } catch (std::exception& e) {
11294       {
11295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11296       };
11297     } catch (...) {
11298       {
11299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11300       };
11301     }
11302   }
11303 }
11304
11305
11306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
11307   void * jresult ;
11308   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11309   Dali::Vector4 *result = 0 ;
11310
11311   arg1 = (Dali::Matrix *)jarg1;
11312   {
11313     try {
11314       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
11315     } catch (std::out_of_range& e) {
11316       {
11317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11318       };
11319     } catch (std::exception& e) {
11320       {
11321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11322       };
11323     } catch (...) {
11324       {
11325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11326       };
11327     }
11328   }
11329   jresult = (void *)result;
11330   return jresult;
11331 }
11332
11333
11334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
11335   void * jresult ;
11336   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11337   Dali::Vector3 *result = 0 ;
11338
11339   arg1 = (Dali::Matrix *)jarg1;
11340   {
11341     try {
11342       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
11343     } catch (std::out_of_range& e) {
11344       {
11345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11346       };
11347     } catch (std::exception& e) {
11348       {
11349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11350       };
11351     } catch (...) {
11352       {
11353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11354       };
11355     }
11356   }
11357   jresult = (void *)result;
11358   return jresult;
11359 }
11360
11361
11362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
11363   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11364   Dali::Vector4 *arg2 = 0 ;
11365
11366   arg1 = (Dali::Matrix *)jarg1;
11367   arg2 = (Dali::Vector4 *)jarg2;
11368   if (!arg2) {
11369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11370     return ;
11371   }
11372   {
11373     try {
11374       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
11375     } catch (std::out_of_range& e) {
11376       {
11377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11378       };
11379     } catch (std::exception& e) {
11380       {
11381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11382       };
11383     } catch (...) {
11384       {
11385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11386       };
11387     }
11388   }
11389 }
11390
11391
11392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
11393   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11394   Dali::Vector3 *arg2 = 0 ;
11395
11396   arg1 = (Dali::Matrix *)jarg1;
11397   arg2 = (Dali::Vector3 *)jarg2;
11398   if (!arg2) {
11399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11400     return ;
11401   }
11402   {
11403     try {
11404       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
11405     } catch (std::out_of_range& e) {
11406       {
11407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11408       };
11409     } catch (std::exception& e) {
11410       {
11411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11412       };
11413     } catch (...) {
11414       {
11415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11416       };
11417     }
11418   }
11419 }
11420
11421
11422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
11423   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11424
11425   arg1 = (Dali::Matrix *)jarg1;
11426   {
11427     try {
11428       (arg1)->OrthoNormalize();
11429     } catch (std::out_of_range& e) {
11430       {
11431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11432       };
11433     } catch (std::exception& e) {
11434       {
11435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11436       };
11437     } catch (...) {
11438       {
11439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11440       };
11441     }
11442   }
11443 }
11444
11445
11446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
11447   void * jresult ;
11448   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11449   float *result = 0 ;
11450
11451   arg1 = (Dali::Matrix *)jarg1;
11452   {
11453     try {
11454       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
11455     } catch (std::out_of_range& e) {
11456       {
11457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11458       };
11459     } catch (std::exception& e) {
11460       {
11461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11462       };
11463     } catch (...) {
11464       {
11465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11466       };
11467     }
11468   }
11469   jresult = (void *)result;
11470   return jresult;
11471 }
11472
11473
11474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
11475   Dali::Matrix *arg1 = 0 ;
11476   Dali::Matrix *arg2 = 0 ;
11477   Dali::Matrix *arg3 = 0 ;
11478
11479   arg1 = (Dali::Matrix *)jarg1;
11480   if (!arg1) {
11481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11482     return ;
11483   }
11484   arg2 = (Dali::Matrix *)jarg2;
11485   if (!arg2) {
11486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11487     return ;
11488   }
11489   arg3 = (Dali::Matrix *)jarg3;
11490   if (!arg3) {
11491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11492     return ;
11493   }
11494   {
11495     try {
11496       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
11497     } catch (std::out_of_range& e) {
11498       {
11499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11500       };
11501     } catch (std::exception& e) {
11502       {
11503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11504       };
11505     } catch (...) {
11506       {
11507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11508       };
11509     }
11510   }
11511 }
11512
11513
11514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
11515   Dali::Matrix *arg1 = 0 ;
11516   Dali::Matrix *arg2 = 0 ;
11517   Dali::Quaternion *arg3 = 0 ;
11518
11519   arg1 = (Dali::Matrix *)jarg1;
11520   if (!arg1) {
11521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11522     return ;
11523   }
11524   arg2 = (Dali::Matrix *)jarg2;
11525   if (!arg2) {
11526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11527     return ;
11528   }
11529   arg3 = (Dali::Quaternion *)jarg3;
11530   if (!arg3) {
11531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11532     return ;
11533   }
11534   {
11535     try {
11536       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
11537     } catch (std::out_of_range& e) {
11538       {
11539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11540       };
11541     } catch (std::exception& e) {
11542       {
11543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11544       };
11545     } catch (...) {
11546       {
11547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11548       };
11549     }
11550   }
11551 }
11552
11553
11554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
11555   void * jresult ;
11556   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11557   Dali::Vector4 *arg2 = 0 ;
11558   Dali::Vector4 result;
11559
11560   arg1 = (Dali::Matrix *)jarg1;
11561   arg2 = (Dali::Vector4 *)jarg2;
11562   if (!arg2) {
11563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11564     return 0;
11565   }
11566   {
11567     try {
11568       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
11569     } catch (std::out_of_range& e) {
11570       {
11571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11572       };
11573     } catch (std::exception& e) {
11574       {
11575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11576       };
11577     } catch (...) {
11578       {
11579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11580       };
11581     }
11582   }
11583   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
11584   return jresult;
11585 }
11586
11587
11588 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
11589   unsigned int jresult ;
11590   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11591   Dali::Matrix *arg2 = 0 ;
11592   bool result;
11593
11594   arg1 = (Dali::Matrix *)jarg1;
11595   arg2 = (Dali::Matrix *)jarg2;
11596   if (!arg2) {
11597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11598     return 0;
11599   }
11600   {
11601     try {
11602       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
11603     } catch (std::out_of_range& e) {
11604       {
11605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11606       };
11607     } catch (std::exception& e) {
11608       {
11609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11610       };
11611     } catch (...) {
11612       {
11613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11614       };
11615     }
11616   }
11617   jresult = result;
11618   return jresult;
11619 }
11620
11621
11622 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
11623   unsigned int jresult ;
11624   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11625   Dali::Matrix *arg2 = 0 ;
11626   bool result;
11627
11628   arg1 = (Dali::Matrix *)jarg1;
11629   arg2 = (Dali::Matrix *)jarg2;
11630   if (!arg2) {
11631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11632     return 0;
11633   }
11634   {
11635     try {
11636       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
11637     } catch (std::out_of_range& e) {
11638       {
11639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11640       };
11641     } catch (std::exception& e) {
11642       {
11643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11644       };
11645     } catch (...) {
11646       {
11647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11648       };
11649     }
11650   }
11651   jresult = result;
11652   return jresult;
11653 }
11654
11655
11656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11657   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11658   Dali::Vector3 *arg2 = 0 ;
11659   Dali::Quaternion *arg3 = 0 ;
11660   Dali::Vector3 *arg4 = 0 ;
11661
11662   arg1 = (Dali::Matrix *)jarg1;
11663   arg2 = (Dali::Vector3 *)jarg2;
11664   if (!arg2) {
11665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11666     return ;
11667   }
11668   arg3 = (Dali::Quaternion *)jarg3;
11669   if (!arg3) {
11670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11671     return ;
11672   }
11673   arg4 = (Dali::Vector3 *)jarg4;
11674   if (!arg4) {
11675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11676     return ;
11677   }
11678   {
11679     try {
11680       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11681     } catch (std::out_of_range& e) {
11682       {
11683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11684       };
11685     } catch (std::exception& e) {
11686       {
11687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11688       };
11689     } catch (...) {
11690       {
11691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11692       };
11693     }
11694   }
11695 }
11696
11697
11698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11699   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11700   Dali::Vector3 *arg2 = 0 ;
11701   Dali::Quaternion *arg3 = 0 ;
11702   Dali::Vector3 *arg4 = 0 ;
11703
11704   arg1 = (Dali::Matrix *)jarg1;
11705   arg2 = (Dali::Vector3 *)jarg2;
11706   if (!arg2) {
11707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11708     return ;
11709   }
11710   arg3 = (Dali::Quaternion *)jarg3;
11711   if (!arg3) {
11712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11713     return ;
11714   }
11715   arg4 = (Dali::Vector3 *)jarg4;
11716   if (!arg4) {
11717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11718     return ;
11719   }
11720   {
11721     try {
11722       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11723     } catch (std::out_of_range& e) {
11724       {
11725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11726       };
11727     } catch (std::exception& e) {
11728       {
11729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11730       };
11731     } catch (...) {
11732       {
11733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11734       };
11735     }
11736   }
11737 }
11738
11739
11740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
11741   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11742   Dali::Vector3 *arg2 = 0 ;
11743   Dali::Vector3 *arg3 = 0 ;
11744   Dali::Vector3 *arg4 = 0 ;
11745   Dali::Vector3 *arg5 = 0 ;
11746
11747   arg1 = (Dali::Matrix *)jarg1;
11748   arg2 = (Dali::Vector3 *)jarg2;
11749   if (!arg2) {
11750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11751     return ;
11752   }
11753   arg3 = (Dali::Vector3 *)jarg3;
11754   if (!arg3) {
11755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11756     return ;
11757   }
11758   arg4 = (Dali::Vector3 *)jarg4;
11759   if (!arg4) {
11760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11761     return ;
11762   }
11763   arg5 = (Dali::Vector3 *)jarg5;
11764   if (!arg5) {
11765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11766     return ;
11767   }
11768   {
11769     try {
11770       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
11771     } catch (std::out_of_range& e) {
11772       {
11773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11774       };
11775     } catch (std::exception& e) {
11776       {
11777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11778       };
11779     } catch (...) {
11780       {
11781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11782       };
11783     }
11784   }
11785 }
11786
11787
11788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11789   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11790   Dali::Vector3 *arg2 = 0 ;
11791   Dali::Quaternion *arg3 = 0 ;
11792   Dali::Vector3 *arg4 = 0 ;
11793
11794   arg1 = (Dali::Matrix *)jarg1;
11795   arg2 = (Dali::Vector3 *)jarg2;
11796   if (!arg2) {
11797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11798     return ;
11799   }
11800   arg3 = (Dali::Quaternion *)jarg3;
11801   if (!arg3) {
11802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
11803     return ;
11804   }
11805   arg4 = (Dali::Vector3 *)jarg4;
11806   if (!arg4) {
11807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11808     return ;
11809   }
11810   {
11811     try {
11812       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
11813     } catch (std::out_of_range& e) {
11814       {
11815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11816       };
11817     } catch (std::exception& e) {
11818       {
11819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11820       };
11821     } catch (...) {
11822       {
11823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11824       };
11825     }
11826   }
11827 }
11828
11829
11830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
11831   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11832
11833   arg1 = (Dali::Matrix *)jarg1;
11834   {
11835     try {
11836       delete arg1;
11837     } catch (std::out_of_range& e) {
11838       {
11839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11840       };
11841     } catch (std::exception& e) {
11842       {
11843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11844       };
11845     } catch (...) {
11846       {
11847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11848       };
11849     }
11850   }
11851 }
11852
11853
11854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
11855   void * jresult ;
11856   Dali::Matrix3 *result = 0 ;
11857
11858   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
11859   jresult = (void *)result;
11860   return jresult;
11861 }
11862
11863
11864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
11865   void * jresult ;
11866   Dali::Matrix3 *result = 0 ;
11867
11868   {
11869     try {
11870       result = (Dali::Matrix3 *)new Dali::Matrix3();
11871     } catch (std::out_of_range& e) {
11872       {
11873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11874       };
11875     } catch (std::exception& e) {
11876       {
11877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11878       };
11879     } catch (...) {
11880       {
11881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11882       };
11883     }
11884   }
11885   jresult = (void *)result;
11886   return jresult;
11887 }
11888
11889
11890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
11891   void * jresult ;
11892   Dali::Matrix3 *arg1 = 0 ;
11893   Dali::Matrix3 *result = 0 ;
11894
11895   arg1 = (Dali::Matrix3 *)jarg1;
11896   if (!arg1) {
11897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
11898     return 0;
11899   }
11900   {
11901     try {
11902       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
11903     } catch (std::out_of_range& e) {
11904       {
11905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11906       };
11907     } catch (std::exception& e) {
11908       {
11909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11910       };
11911     } catch (...) {
11912       {
11913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11914       };
11915     }
11916   }
11917   jresult = (void *)result;
11918   return jresult;
11919 }
11920
11921
11922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
11923   void * jresult ;
11924   Dali::Matrix *arg1 = 0 ;
11925   Dali::Matrix3 *result = 0 ;
11926
11927   arg1 = (Dali::Matrix *)jarg1;
11928   if (!arg1) {
11929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11930     return 0;
11931   }
11932   {
11933     try {
11934       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
11935     } catch (std::out_of_range& e) {
11936       {
11937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11938       };
11939     } catch (std::exception& e) {
11940       {
11941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11942       };
11943     } catch (...) {
11944       {
11945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11946       };
11947     }
11948   }
11949   jresult = (void *)result;
11950   return jresult;
11951 }
11952
11953
11954 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) {
11955   void * jresult ;
11956   float arg1 ;
11957   float arg2 ;
11958   float arg3 ;
11959   float arg4 ;
11960   float arg5 ;
11961   float arg6 ;
11962   float arg7 ;
11963   float arg8 ;
11964   float arg9 ;
11965   Dali::Matrix3 *result = 0 ;
11966
11967   arg1 = (float)jarg1;
11968   arg2 = (float)jarg2;
11969   arg3 = (float)jarg3;
11970   arg4 = (float)jarg4;
11971   arg5 = (float)jarg5;
11972   arg6 = (float)jarg6;
11973   arg7 = (float)jarg7;
11974   arg8 = (float)jarg8;
11975   arg9 = (float)jarg9;
11976   {
11977     try {
11978       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
11979     } catch (std::out_of_range& e) {
11980       {
11981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11982       };
11983     } catch (std::exception& e) {
11984       {
11985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11986       };
11987     } catch (...) {
11988       {
11989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11990       };
11991     }
11992   }
11993   jresult = (void *)result;
11994   return jresult;
11995 }
11996
11997
11998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
11999   void * jresult ;
12000   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12001   Dali::Matrix3 *arg2 = 0 ;
12002   Dali::Matrix3 *result = 0 ;
12003
12004   arg1 = (Dali::Matrix3 *)jarg1;
12005   arg2 = (Dali::Matrix3 *)jarg2;
12006   if (!arg2) {
12007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12008     return 0;
12009   }
12010   {
12011     try {
12012       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
12013     } catch (std::out_of_range& e) {
12014       {
12015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12016       };
12017     } catch (std::exception& e) {
12018       {
12019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12020       };
12021     } catch (...) {
12022       {
12023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12024       };
12025     }
12026   }
12027   jresult = (void *)result;
12028   return jresult;
12029 }
12030
12031
12032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
12033   void * jresult ;
12034   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12035   Dali::Matrix *arg2 = 0 ;
12036   Dali::Matrix3 *result = 0 ;
12037
12038   arg1 = (Dali::Matrix3 *)jarg1;
12039   arg2 = (Dali::Matrix *)jarg2;
12040   if (!arg2) {
12041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12042     return 0;
12043   }
12044   {
12045     try {
12046       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12047     } catch (std::out_of_range& e) {
12048       {
12049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12050       };
12051     } catch (std::exception& e) {
12052       {
12053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12054       };
12055     } catch (...) {
12056       {
12057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12058       };
12059     }
12060   }
12061   jresult = (void *)result;
12062   return jresult;
12063 }
12064
12065
12066 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
12067   unsigned int jresult ;
12068   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12069   Dali::Matrix3 *arg2 = 0 ;
12070   bool result;
12071
12072   arg1 = (Dali::Matrix3 *)jarg1;
12073   arg2 = (Dali::Matrix3 *)jarg2;
12074   if (!arg2) {
12075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12076     return 0;
12077   }
12078   {
12079     try {
12080       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
12081     } catch (std::out_of_range& e) {
12082       {
12083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12084       };
12085     } catch (std::exception& e) {
12086       {
12087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12088       };
12089     } catch (...) {
12090       {
12091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12092       };
12093     }
12094   }
12095   jresult = result;
12096   return jresult;
12097 }
12098
12099
12100 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
12101   unsigned int jresult ;
12102   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12103   Dali::Matrix3 *arg2 = 0 ;
12104   bool result;
12105
12106   arg1 = (Dali::Matrix3 *)jarg1;
12107   arg2 = (Dali::Matrix3 *)jarg2;
12108   if (!arg2) {
12109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12110     return 0;
12111   }
12112   {
12113     try {
12114       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
12115     } catch (std::out_of_range& e) {
12116       {
12117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12118       };
12119     } catch (std::exception& e) {
12120       {
12121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12122       };
12123     } catch (...) {
12124       {
12125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12126       };
12127     }
12128   }
12129   jresult = result;
12130   return jresult;
12131 }
12132
12133
12134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
12135   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12136
12137   arg1 = (Dali::Matrix3 *)jarg1;
12138   {
12139     try {
12140       delete arg1;
12141     } catch (std::out_of_range& e) {
12142       {
12143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12144       };
12145     } catch (std::exception& e) {
12146       {
12147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12148       };
12149     } catch (...) {
12150       {
12151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12152       };
12153     }
12154   }
12155 }
12156
12157
12158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
12159   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12160
12161   arg1 = (Dali::Matrix3 *)jarg1;
12162   {
12163     try {
12164       (arg1)->SetIdentity();
12165     } catch (std::out_of_range& e) {
12166       {
12167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12168       };
12169     } catch (std::exception& e) {
12170       {
12171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12172       };
12173     } catch (...) {
12174       {
12175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12176       };
12177     }
12178   }
12179 }
12180
12181
12182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
12183   void * jresult ;
12184   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12185   float *result = 0 ;
12186
12187   arg1 = (Dali::Matrix3 *)jarg1;
12188   {
12189     try {
12190       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
12191     } catch (std::out_of_range& e) {
12192       {
12193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12194       };
12195     } catch (std::exception& e) {
12196       {
12197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12198       };
12199     } catch (...) {
12200       {
12201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12202       };
12203     }
12204   }
12205   jresult = (void *)result;
12206   return jresult;
12207 }
12208
12209
12210 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
12211   unsigned int jresult ;
12212   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12213   bool result;
12214
12215   arg1 = (Dali::Matrix3 *)jarg1;
12216   {
12217     try {
12218       result = (bool)(arg1)->Invert();
12219     } catch (std::out_of_range& e) {
12220       {
12221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12222       };
12223     } catch (std::exception& e) {
12224       {
12225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12226       };
12227     } catch (...) {
12228       {
12229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12230       };
12231     }
12232   }
12233   jresult = result;
12234   return jresult;
12235 }
12236
12237
12238 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
12239   unsigned int jresult ;
12240   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12241   bool result;
12242
12243   arg1 = (Dali::Matrix3 *)jarg1;
12244   {
12245     try {
12246       result = (bool)(arg1)->Transpose();
12247     } catch (std::out_of_range& e) {
12248       {
12249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12250       };
12251     } catch (std::exception& e) {
12252       {
12253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12254       };
12255     } catch (...) {
12256       {
12257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12258       };
12259     }
12260   }
12261   jresult = result;
12262   return jresult;
12263 }
12264
12265
12266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
12267   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12268   float arg2 ;
12269
12270   arg1 = (Dali::Matrix3 *)jarg1;
12271   arg2 = (float)jarg2;
12272   {
12273     try {
12274       (arg1)->Scale(arg2);
12275     } catch (std::out_of_range& e) {
12276       {
12277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12278       };
12279     } catch (std::exception& e) {
12280       {
12281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12282       };
12283     } catch (...) {
12284       {
12285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12286       };
12287     }
12288   }
12289 }
12290
12291
12292 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
12293   float jresult ;
12294   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12295   float result;
12296
12297   arg1 = (Dali::Matrix3 *)jarg1;
12298   {
12299     try {
12300       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
12301     } catch (std::out_of_range& e) {
12302       {
12303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12304       };
12305     } catch (std::exception& e) {
12306       {
12307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12308       };
12309     } catch (...) {
12310       {
12311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12312       };
12313     }
12314   }
12315   jresult = result;
12316   return jresult;
12317 }
12318
12319
12320 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
12321   unsigned int jresult ;
12322   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12323   bool result;
12324
12325   arg1 = (Dali::Matrix3 *)jarg1;
12326   {
12327     try {
12328       result = (bool)(arg1)->ScaledInverseTranspose();
12329     } catch (std::out_of_range& e) {
12330       {
12331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12332       };
12333     } catch (std::exception& e) {
12334       {
12335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12336       };
12337     } catch (...) {
12338       {
12339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12340       };
12341     }
12342   }
12343   jresult = result;
12344   return jresult;
12345 }
12346
12347
12348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
12349   Dali::Matrix3 *arg1 = 0 ;
12350   Dali::Matrix3 *arg2 = 0 ;
12351   Dali::Matrix3 *arg3 = 0 ;
12352
12353   arg1 = (Dali::Matrix3 *)jarg1;
12354   if (!arg1) {
12355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
12356     return ;
12357   }
12358   arg2 = (Dali::Matrix3 *)jarg2;
12359   if (!arg2) {
12360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12361     return ;
12362   }
12363   arg3 = (Dali::Matrix3 *)jarg3;
12364   if (!arg3) {
12365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12366     return ;
12367   }
12368   {
12369     try {
12370       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
12371     } catch (std::out_of_range& e) {
12372       {
12373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12374       };
12375     } catch (std::exception& e) {
12376       {
12377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12378       };
12379     } catch (...) {
12380       {
12381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12382       };
12383     }
12384   }
12385 }
12386
12387
12388 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
12389   float jresult ;
12390   float arg1 ;
12391   float arg2 ;
12392   float result;
12393
12394   arg1 = (float)jarg1;
12395   arg2 = (float)jarg2;
12396   {
12397     try {
12398       result = (float)Dali::Random::Range(arg1,arg2);
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 void * SWIGSTDCALL CSharp_Dali_Axis() {
12419   void * jresult ;
12420   Dali::Vector4 result;
12421
12422   {
12423     try {
12424       result = Dali::Random::Axis();
12425     } catch (std::out_of_range& e) {
12426       {
12427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12428       };
12429     } catch (std::exception& e) {
12430       {
12431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12432       };
12433     } catch (...) {
12434       {
12435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12436       };
12437     }
12438   }
12439   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
12440   return jresult;
12441 }
12442
12443
12444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
12445   void * jresult ;
12446   Dali::AngleAxis *result = 0 ;
12447
12448   {
12449     try {
12450       result = (Dali::AngleAxis *)new Dali::AngleAxis();
12451     } catch (std::out_of_range& e) {
12452       {
12453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12454       };
12455     } catch (std::exception& e) {
12456       {
12457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12458       };
12459     } catch (...) {
12460       {
12461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12462       };
12463     }
12464   }
12465   jresult = (void *)result;
12466   return jresult;
12467 }
12468
12469
12470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
12471   void * jresult ;
12472   Dali::Radian arg1 ;
12473   Dali::Vector3 *arg2 = 0 ;
12474   Dali::Radian *argp1 ;
12475   Dali::AngleAxis *result = 0 ;
12476
12477   argp1 = (Dali::Radian *)jarg1;
12478   if (!argp1) {
12479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
12480     return 0;
12481   }
12482   arg1 = *argp1;
12483   arg2 = (Dali::Vector3 *)jarg2;
12484   if (!arg2) {
12485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12486     return 0;
12487   }
12488   {
12489     try {
12490       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
12491     } catch (std::out_of_range& e) {
12492       {
12493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12494       };
12495     } catch (std::exception& e) {
12496       {
12497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12498       };
12499     } catch (...) {
12500       {
12501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12502       };
12503     }
12504   }
12505   jresult = (void *)result;
12506   return jresult;
12507 }
12508
12509
12510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
12511   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12512   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
12513
12514   arg1 = (Dali::AngleAxis *)jarg1;
12515   arg2 = (Dali::Radian *)jarg2;
12516   if (arg1) (arg1)->angle = *arg2;
12517 }
12518
12519
12520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
12521   void * jresult ;
12522   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12523   Dali::Radian *result = 0 ;
12524
12525   arg1 = (Dali::AngleAxis *)jarg1;
12526   result = (Dali::Radian *)& ((arg1)->angle);
12527   jresult = (void *)result;
12528   return jresult;
12529 }
12530
12531
12532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
12533   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12534   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
12535
12536   arg1 = (Dali::AngleAxis *)jarg1;
12537   arg2 = (Dali::Vector3 *)jarg2;
12538   if (arg1) (arg1)->axis = *arg2;
12539 }
12540
12541
12542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
12543   void * jresult ;
12544   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12545   Dali::Vector3 *result = 0 ;
12546
12547   arg1 = (Dali::AngleAxis *)jarg1;
12548   result = (Dali::Vector3 *)& ((arg1)->axis);
12549   jresult = (void *)result;
12550   return jresult;
12551 }
12552
12553
12554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
12555   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12556
12557   arg1 = (Dali::AngleAxis *)jarg1;
12558   {
12559     try {
12560       delete arg1;
12561     } catch (std::out_of_range& e) {
12562       {
12563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12564       };
12565     } catch (std::exception& e) {
12566       {
12567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12568       };
12569     } catch (...) {
12570       {
12571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12572       };
12573     }
12574   }
12575 }
12576
12577
12578 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
12579   unsigned int jresult ;
12580   Dali::AngleAxis *arg1 = 0 ;
12581   Dali::AngleAxis *arg2 = 0 ;
12582   bool result;
12583
12584   arg1 = (Dali::AngleAxis *)jarg1;
12585   if (!arg1) {
12586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12587     return 0;
12588   }
12589   arg2 = (Dali::AngleAxis *)jarg2;
12590   if (!arg2) {
12591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12592     return 0;
12593   }
12594   {
12595     try {
12596       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
12597     } catch (std::out_of_range& e) {
12598       {
12599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12600       };
12601     } catch (std::exception& e) {
12602       {
12603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12604       };
12605     } catch (...) {
12606       {
12607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12608       };
12609     }
12610   }
12611   jresult = result;
12612   return jresult;
12613 }
12614
12615
12616 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
12617   unsigned int jresult ;
12618   unsigned int arg1 ;
12619   unsigned int result;
12620
12621   arg1 = (unsigned int)jarg1;
12622   {
12623     try {
12624       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
12625     } catch (std::out_of_range& e) {
12626       {
12627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12628       };
12629     } catch (std::exception& e) {
12630       {
12631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12632       };
12633     } catch (...) {
12634       {
12635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12636       };
12637     }
12638   }
12639   jresult = result;
12640   return jresult;
12641 }
12642
12643
12644 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
12645   unsigned int jresult ;
12646   unsigned int arg1 ;
12647   bool result;
12648
12649   arg1 = (unsigned int)jarg1;
12650   {
12651     try {
12652       result = (bool)Dali::IsPowerOfTwo(arg1);
12653     } catch (std::out_of_range& e) {
12654       {
12655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12656       };
12657     } catch (std::exception& e) {
12658       {
12659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12660       };
12661     } catch (...) {
12662       {
12663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12664       };
12665     }
12666   }
12667   jresult = result;
12668   return jresult;
12669 }
12670
12671
12672 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
12673   float jresult ;
12674   float arg1 ;
12675   float arg2 ;
12676   float result;
12677
12678   arg1 = (float)jarg1;
12679   arg2 = (float)jarg2;
12680   {
12681     try {
12682       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
12683     } catch (std::out_of_range& e) {
12684       {
12685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12686       };
12687     } catch (std::exception& e) {
12688       {
12689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12690       };
12691     } catch (...) {
12692       {
12693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12694       };
12695     }
12696   }
12697   jresult = result;
12698   return jresult;
12699 }
12700
12701
12702 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
12703   unsigned int jresult ;
12704   float arg1 ;
12705   bool result;
12706
12707   arg1 = (float)jarg1;
12708   {
12709     try {
12710       result = (bool)Dali::EqualsZero(arg1);
12711     } catch (std::out_of_range& e) {
12712       {
12713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12714       };
12715     } catch (std::exception& e) {
12716       {
12717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12718       };
12719     } catch (...) {
12720       {
12721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12722       };
12723     }
12724   }
12725   jresult = result;
12726   return jresult;
12727 }
12728
12729
12730 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
12731   unsigned int jresult ;
12732   float arg1 ;
12733   float arg2 ;
12734   bool result;
12735
12736   arg1 = (float)jarg1;
12737   arg2 = (float)jarg2;
12738   {
12739     try {
12740       result = (bool)Dali::Equals(arg1,arg2);
12741     } catch (std::out_of_range& e) {
12742       {
12743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12744       };
12745     } catch (std::exception& e) {
12746       {
12747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12748       };
12749     } catch (...) {
12750       {
12751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12752       };
12753     }
12754   }
12755   jresult = result;
12756   return jresult;
12757 }
12758
12759
12760 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
12761   unsigned int jresult ;
12762   float arg1 ;
12763   float arg2 ;
12764   float arg3 ;
12765   bool result;
12766
12767   arg1 = (float)jarg1;
12768   arg2 = (float)jarg2;
12769   arg3 = (float)jarg3;
12770   {
12771     try {
12772       result = (bool)Dali::Equals(arg1,arg2,arg3);
12773     } catch (std::out_of_range& e) {
12774       {
12775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12776       };
12777     } catch (std::exception& e) {
12778       {
12779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12780       };
12781     } catch (...) {
12782       {
12783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12784       };
12785     }
12786   }
12787   jresult = result;
12788   return jresult;
12789 }
12790
12791
12792 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
12793   float jresult ;
12794   float arg1 ;
12795   int arg2 ;
12796   float result;
12797
12798   arg1 = (float)jarg1;
12799   arg2 = (int)jarg2;
12800   {
12801     try {
12802       result = (float)Dali::Round(arg1,arg2);
12803     } catch (std::out_of_range& e) {
12804       {
12805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12806       };
12807     } catch (std::exception& e) {
12808       {
12809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12810       };
12811     } catch (...) {
12812       {
12813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12814       };
12815     }
12816   }
12817   jresult = result;
12818   return jresult;
12819 }
12820
12821
12822 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
12823   float jresult ;
12824   float arg1 ;
12825   float arg2 ;
12826   float arg3 ;
12827   float result;
12828
12829   arg1 = (float)jarg1;
12830   arg2 = (float)jarg2;
12831   arg3 = (float)jarg3;
12832   {
12833     try {
12834       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
12835     } catch (std::out_of_range& e) {
12836       {
12837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12838       };
12839     } catch (std::exception& e) {
12840       {
12841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12842       };
12843     } catch (...) {
12844       {
12845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12846       };
12847     }
12848   }
12849   jresult = result;
12850   return jresult;
12851 }
12852
12853
12854 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
12855   float jresult ;
12856   float arg1 ;
12857   float arg2 ;
12858   float arg3 ;
12859   float arg4 ;
12860   float result;
12861
12862   arg1 = (float)jarg1;
12863   arg2 = (float)jarg2;
12864   arg3 = (float)jarg3;
12865   arg4 = (float)jarg4;
12866   {
12867     try {
12868       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
12869     } catch (std::out_of_range& e) {
12870       {
12871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12872       };
12873     } catch (std::exception& e) {
12874       {
12875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12876       };
12877     } catch (...) {
12878       {
12879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12880       };
12881     }
12882   }
12883   jresult = result;
12884   return jresult;
12885 }
12886
12887
12888 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
12889   int jresult ;
12890   int result;
12891
12892   result = (int)(int)Dali::Property::INVALID_INDEX;
12893   jresult = result;
12894   return jresult;
12895 }
12896
12897
12898 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
12899   int jresult ;
12900   int result;
12901
12902   result = (int)(int)Dali::Property::INVALID_KEY;
12903   jresult = result;
12904   return jresult;
12905 }
12906
12907
12908 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
12909   int jresult ;
12910   int result;
12911
12912   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
12913   jresult = result;
12914   return jresult;
12915 }
12916
12917
12918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
12919   void * jresult ;
12920   Dali::Handle *arg1 = 0 ;
12921   Dali::Property::Index arg2 ;
12922   Dali::Property *result = 0 ;
12923
12924   arg1 = (Dali::Handle *)jarg1;
12925   if (!arg1) {
12926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
12927     return 0;
12928   }
12929   arg2 = (Dali::Property::Index)jarg2;
12930   {
12931     try {
12932       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
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 = (void *)result;
12948   return jresult;
12949 }
12950
12951
12952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
12953   void * jresult ;
12954   Dali::Handle *arg1 = 0 ;
12955   Dali::Property::Index arg2 ;
12956   int arg3 ;
12957   Dali::Property *result = 0 ;
12958
12959   arg1 = (Dali::Handle *)jarg1;
12960   if (!arg1) {
12961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
12962     return 0;
12963   }
12964   arg2 = (Dali::Property::Index)jarg2;
12965   arg3 = (int)jarg3;
12966   {
12967     try {
12968       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
12969     } catch (std::out_of_range& e) {
12970       {
12971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12972       };
12973     } catch (std::exception& e) {
12974       {
12975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12976       };
12977     } catch (...) {
12978       {
12979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12980       };
12981     }
12982   }
12983   jresult = (void *)result;
12984   return jresult;
12985 }
12986
12987
12988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
12989   void * jresult ;
12990   Dali::Handle *arg1 = 0 ;
12991   std::string *arg2 = 0 ;
12992   Dali::Property *result = 0 ;
12993
12994   arg1 = (Dali::Handle *)jarg1;
12995   if (!arg1) {
12996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
12997     return 0;
12998   }
12999   if (!jarg2) {
13000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13001     return 0;
13002   }
13003   std::string arg2_str(jarg2);
13004   arg2 = &arg2_str;
13005   {
13006     try {
13007       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
13008     } catch (std::out_of_range& e) {
13009       {
13010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13011       };
13012     } catch (std::exception& e) {
13013       {
13014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13015       };
13016     } catch (...) {
13017       {
13018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13019       };
13020     }
13021   }
13022   jresult = (void *)result;
13023
13024   //argout typemap for const std::string&
13025
13026   return jresult;
13027 }
13028
13029
13030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
13031   void * jresult ;
13032   Dali::Handle *arg1 = 0 ;
13033   std::string *arg2 = 0 ;
13034   int arg3 ;
13035   Dali::Property *result = 0 ;
13036
13037   arg1 = (Dali::Handle *)jarg1;
13038   if (!arg1) {
13039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13040     return 0;
13041   }
13042   if (!jarg2) {
13043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13044     return 0;
13045   }
13046   std::string arg2_str(jarg2);
13047   arg2 = &arg2_str;
13048   arg3 = (int)jarg3;
13049   {
13050     try {
13051       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
13052     } catch (std::out_of_range& e) {
13053       {
13054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13055       };
13056     } catch (std::exception& e) {
13057       {
13058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13059       };
13060     } catch (...) {
13061       {
13062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13063       };
13064     }
13065   }
13066   jresult = (void *)result;
13067
13068   //argout typemap for const std::string&
13069
13070   return jresult;
13071 }
13072
13073
13074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
13075   Dali::Property *arg1 = (Dali::Property *) 0 ;
13076
13077   arg1 = (Dali::Property *)jarg1;
13078   {
13079     try {
13080       delete arg1;
13081     } catch (std::out_of_range& e) {
13082       {
13083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13084       };
13085     } catch (std::exception& e) {
13086       {
13087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13088       };
13089     } catch (...) {
13090       {
13091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13092       };
13093     }
13094   }
13095 }
13096
13097
13098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
13099   Dali::Property *arg1 = (Dali::Property *) 0 ;
13100   Dali::Handle *arg2 = 0 ;
13101
13102   arg1 = (Dali::Property *)jarg1;
13103   arg2 = (Dali::Handle *)jarg2;
13104   if (!arg2) {
13105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13106     return ;
13107   }
13108   if (arg1) (arg1)->object = *arg2;
13109 }
13110
13111
13112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
13113   void * jresult ;
13114   Dali::Property *arg1 = (Dali::Property *) 0 ;
13115   Dali::Handle *result = 0 ;
13116
13117   arg1 = (Dali::Property *)jarg1;
13118   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
13119   jresult = (void *)result;
13120   return jresult;
13121 }
13122
13123
13124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
13125   Dali::Property *arg1 = (Dali::Property *) 0 ;
13126   Dali::Property::Index arg2 ;
13127
13128   arg1 = (Dali::Property *)jarg1;
13129   arg2 = (Dali::Property::Index)jarg2;
13130   if (arg1) (arg1)->propertyIndex = arg2;
13131 }
13132
13133
13134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
13135   int jresult ;
13136   Dali::Property *arg1 = (Dali::Property *) 0 ;
13137   Dali::Property::Index result;
13138
13139   arg1 = (Dali::Property *)jarg1;
13140   result = (Dali::Property::Index) ((arg1)->propertyIndex);
13141   jresult = result;
13142   return jresult;
13143 }
13144
13145
13146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
13147   Dali::Property *arg1 = (Dali::Property *) 0 ;
13148   int arg2 ;
13149
13150   arg1 = (Dali::Property *)jarg1;
13151   arg2 = (int)jarg2;
13152   if (arg1) (arg1)->componentIndex = arg2;
13153 }
13154
13155
13156 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
13157   int jresult ;
13158   Dali::Property *arg1 = (Dali::Property *) 0 ;
13159   int result;
13160
13161   arg1 = (Dali::Property *)jarg1;
13162   result = (int) ((arg1)->componentIndex);
13163   jresult = result;
13164   return jresult;
13165 }
13166
13167
13168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
13169   void * jresult ;
13170   Dali::Property::Array *result = 0 ;
13171
13172   {
13173     try {
13174       result = (Dali::Property::Array *)new Dali::Property::Array();
13175     } catch (std::out_of_range& e) {
13176       {
13177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13178       };
13179     } catch (std::exception& e) {
13180       {
13181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13182       };
13183     } catch (...) {
13184       {
13185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13186       };
13187     }
13188   }
13189   jresult = (void *)result;
13190   return jresult;
13191 }
13192
13193
13194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
13195   void * jresult ;
13196   Dali::Property::Array *arg1 = 0 ;
13197   Dali::Property::Array *result = 0 ;
13198
13199   arg1 = (Dali::Property::Array *)jarg1;
13200   if (!arg1) {
13201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13202     return 0;
13203   }
13204   {
13205     try {
13206       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
13207     } catch (std::out_of_range& e) {
13208       {
13209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13210       };
13211     } catch (std::exception& e) {
13212       {
13213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13214       };
13215     } catch (...) {
13216       {
13217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13218       };
13219     }
13220   }
13221   jresult = (void *)result;
13222   return jresult;
13223 }
13224
13225
13226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
13227   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13228
13229   arg1 = (Dali::Property::Array *)jarg1;
13230   {
13231     try {
13232       delete arg1;
13233     } catch (std::out_of_range& e) {
13234       {
13235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13236       };
13237     } catch (std::exception& e) {
13238       {
13239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13240       };
13241     } catch (...) {
13242       {
13243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13244       };
13245     }
13246   }
13247 }
13248
13249
13250 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
13251   unsigned long jresult ;
13252   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13253   Dali::Property::Array::SizeType result;
13254
13255   arg1 = (Dali::Property::Array *)jarg1;
13256   {
13257     try {
13258       result = ((Dali::Property::Array const *)arg1)->Size();
13259     } catch (std::out_of_range& e) {
13260       {
13261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13262       };
13263     } catch (std::exception& e) {
13264       {
13265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13266       };
13267     } catch (...) {
13268       {
13269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13270       };
13271     }
13272   }
13273   jresult = (unsigned long)result;
13274   return jresult;
13275 }
13276
13277
13278 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
13279   unsigned long jresult ;
13280   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13281   Dali::Property::Array::SizeType result;
13282
13283   arg1 = (Dali::Property::Array *)jarg1;
13284   {
13285     try {
13286       result = ((Dali::Property::Array const *)arg1)->Count();
13287     } catch (std::out_of_range& e) {
13288       {
13289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13290       };
13291     } catch (std::exception& e) {
13292       {
13293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13294       };
13295     } catch (...) {
13296       {
13297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13298       };
13299     }
13300   }
13301   jresult = (unsigned long)result;
13302   return jresult;
13303 }
13304
13305
13306 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
13307   unsigned int jresult ;
13308   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13309   bool result;
13310
13311   arg1 = (Dali::Property::Array *)jarg1;
13312   {
13313     try {
13314       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
13315     } catch (std::out_of_range& e) {
13316       {
13317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13318       };
13319     } catch (std::exception& e) {
13320       {
13321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13322       };
13323     } catch (...) {
13324       {
13325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13326       };
13327     }
13328   }
13329   jresult = result;
13330   return jresult;
13331 }
13332
13333
13334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
13335   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13336
13337   arg1 = (Dali::Property::Array *)jarg1;
13338   {
13339     try {
13340       (arg1)->Clear();
13341     } catch (std::out_of_range& e) {
13342       {
13343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13344       };
13345     } catch (std::exception& e) {
13346       {
13347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13348       };
13349     } catch (...) {
13350       {
13351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13352       };
13353     }
13354   }
13355 }
13356
13357
13358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
13359   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13360   Dali::Property::Array::SizeType arg2 ;
13361
13362   arg1 = (Dali::Property::Array *)jarg1;
13363   arg2 = (Dali::Property::Array::SizeType)jarg2;
13364   {
13365     try {
13366       (arg1)->Reserve(arg2);
13367     } catch (std::out_of_range& e) {
13368       {
13369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13370       };
13371     } catch (std::exception& e) {
13372       {
13373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13374       };
13375     } catch (...) {
13376       {
13377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13378       };
13379     }
13380   }
13381 }
13382
13383
13384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
13385   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13386   Dali::Property::Array::SizeType arg2 ;
13387
13388   arg1 = (Dali::Property::Array *)jarg1;
13389   arg2 = (Dali::Property::Array::SizeType)jarg2;
13390   {
13391     try {
13392       (arg1)->Resize(arg2);
13393     } catch (std::out_of_range& e) {
13394       {
13395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13396       };
13397     } catch (std::exception& e) {
13398       {
13399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13400       };
13401     } catch (...) {
13402       {
13403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13404       };
13405     }
13406   }
13407 }
13408
13409
13410 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
13411   unsigned long jresult ;
13412   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13413   Dali::Property::Array::SizeType result;
13414
13415   arg1 = (Dali::Property::Array *)jarg1;
13416   {
13417     try {
13418       result = (arg1)->Capacity();
13419     } catch (std::out_of_range& e) {
13420       {
13421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13422       };
13423     } catch (std::exception& e) {
13424       {
13425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13426       };
13427     } catch (...) {
13428       {
13429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13430       };
13431     }
13432   }
13433   jresult = (unsigned long)result;
13434   return jresult;
13435 }
13436
13437
13438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
13439   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13440   Dali::Property::Value *arg2 = 0 ;
13441
13442   arg1 = (Dali::Property::Array *)jarg1;
13443   arg2 = (Dali::Property::Value *)jarg2;
13444   if (!arg2) {
13445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13446     return ;
13447   }
13448   {
13449     try {
13450       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
13451     } catch (std::out_of_range& e) {
13452       {
13453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13454       };
13455     } catch (std::exception& e) {
13456       {
13457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13458       };
13459     } catch (...) {
13460       {
13461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13462       };
13463     }
13464   }
13465 }
13466
13467
13468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
13469   void * jresult ;
13470   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13471   Dali::Property::Value *arg2 = 0 ;
13472   Dali::Property::Array *result = 0 ;
13473
13474   arg1 = (Dali::Property::Array *)jarg1;
13475   arg2 = (Dali::Property::Value *)jarg2;
13476   if (!arg2) {
13477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13478     return 0;
13479   }
13480   {
13481     try {
13482       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
13483     } catch (std::out_of_range& e) {
13484       {
13485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13486       };
13487     } catch (std::exception& e) {
13488       {
13489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13490       };
13491     } catch (...) {
13492       {
13493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13494       };
13495     }
13496   }
13497   jresult = (void *)result;
13498   return jresult;
13499 }
13500
13501
13502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
13503   void * jresult ;
13504   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13505   Dali::Property::Array::SizeType arg2 ;
13506   Dali::Property::Value *result = 0 ;
13507
13508   arg1 = (Dali::Property::Array *)jarg1;
13509   arg2 = (Dali::Property::Array::SizeType)jarg2;
13510   {
13511     try {
13512       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
13513     } catch (std::out_of_range& e) {
13514       {
13515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13516       };
13517     } catch (std::exception& e) {
13518       {
13519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13520       };
13521     } catch (...) {
13522       {
13523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13524       };
13525     }
13526   }
13527   jresult = (void *)result;
13528   return jresult;
13529 }
13530
13531
13532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
13533   void * jresult ;
13534   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13535   Dali::Property::Array::SizeType arg2 ;
13536   Dali::Property::Value *result = 0 ;
13537
13538   arg1 = (Dali::Property::Array *)jarg1;
13539   arg2 = (Dali::Property::Array::SizeType)jarg2;
13540   {
13541     try {
13542       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
13543     } catch (std::out_of_range& e) {
13544       {
13545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13546       };
13547     } catch (std::exception& e) {
13548       {
13549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13550       };
13551     } catch (...) {
13552       {
13553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13554       };
13555     }
13556   }
13557   jresult = (void *)result;
13558   return jresult;
13559 }
13560
13561
13562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
13563   void * jresult ;
13564   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13565   Dali::Property::Array *arg2 = 0 ;
13566   Dali::Property::Array *result = 0 ;
13567
13568   arg1 = (Dali::Property::Array *)jarg1;
13569   arg2 = (Dali::Property::Array *)jarg2;
13570   if (!arg2) {
13571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13572     return 0;
13573   }
13574   {
13575     try {
13576       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
13577     } catch (std::out_of_range& e) {
13578       {
13579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13580       };
13581     } catch (std::exception& e) {
13582       {
13583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13584       };
13585     } catch (...) {
13586       {
13587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13588       };
13589     }
13590   }
13591   jresult = (void *)result;
13592   return jresult;
13593 }
13594
13595
13596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
13597   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13598   enum Dali::Property::Key::Type arg2 ;
13599
13600   arg1 = (Dali::Property::Key *)jarg1;
13601   arg2 = (enum Dali::Property::Key::Type)jarg2;
13602   if (arg1) (arg1)->type = arg2;
13603 }
13604
13605
13606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
13607   int jresult ;
13608   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13609   enum Dali::Property::Key::Type result;
13610
13611   arg1 = (Dali::Property::Key *)jarg1;
13612   result = (enum Dali::Property::Key::Type) ((arg1)->type);
13613   jresult = (int)result;
13614   return jresult;
13615 }
13616
13617
13618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
13619   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13620   Dali::Property::Index arg2 ;
13621
13622   arg1 = (Dali::Property::Key *)jarg1;
13623   arg2 = (Dali::Property::Index)jarg2;
13624   if (arg1) (arg1)->indexKey = arg2;
13625 }
13626
13627
13628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
13629   int jresult ;
13630   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13631   Dali::Property::Index result;
13632
13633   arg1 = (Dali::Property::Key *)jarg1;
13634   result = (Dali::Property::Index) ((arg1)->indexKey);
13635   jresult = result;
13636   return jresult;
13637 }
13638
13639
13640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
13641   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13642   std::string *arg2 = 0 ;
13643
13644   arg1 = (Dali::Property::Key *)jarg1;
13645   if (!jarg2) {
13646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13647     return ;
13648   }
13649   std::string arg2_str(jarg2);
13650   arg2 = &arg2_str;
13651   if (arg1) (arg1)->stringKey = *arg2;
13652
13653   //argout typemap for const std::string&
13654
13655 }
13656
13657
13658 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
13659   char * jresult ;
13660   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13661   std::string *result = 0 ;
13662
13663   arg1 = (Dali::Property::Key *)jarg1;
13664   result = (std::string *) & ((arg1)->stringKey);
13665   jresult = SWIG_csharp_string_callback(result->c_str());
13666   return jresult;
13667 }
13668
13669
13670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
13671   void * jresult ;
13672   std::string *arg1 = 0 ;
13673   Dali::Property::Key *result = 0 ;
13674
13675   if (!jarg1) {
13676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13677     return 0;
13678   }
13679   std::string arg1_str(jarg1);
13680   arg1 = &arg1_str;
13681   {
13682     try {
13683       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
13684     } catch (std::out_of_range& e) {
13685       {
13686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13687       };
13688     } catch (std::exception& e) {
13689       {
13690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13691       };
13692     } catch (...) {
13693       {
13694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13695       };
13696     }
13697   }
13698   jresult = (void *)result;
13699
13700   //argout typemap for const std::string&
13701
13702   return jresult;
13703 }
13704
13705
13706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
13707   void * jresult ;
13708   Dali::Property::Index arg1 ;
13709   Dali::Property::Key *result = 0 ;
13710
13711   arg1 = (Dali::Property::Index)jarg1;
13712   {
13713     try {
13714       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
13715     } catch (std::out_of_range& e) {
13716       {
13717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13718       };
13719     } catch (std::exception& e) {
13720       {
13721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13722       };
13723     } catch (...) {
13724       {
13725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13726       };
13727     }
13728   }
13729   jresult = (void *)result;
13730   return jresult;
13731 }
13732
13733
13734 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
13735   unsigned int jresult ;
13736   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13737   std::string *arg2 = 0 ;
13738   bool result;
13739
13740   arg1 = (Dali::Property::Key *)jarg1;
13741   if (!jarg2) {
13742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13743     return 0;
13744   }
13745   std::string arg2_str(jarg2);
13746   arg2 = &arg2_str;
13747   {
13748     try {
13749       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
13750     } catch (std::out_of_range& e) {
13751       {
13752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13753       };
13754     } catch (std::exception& e) {
13755       {
13756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13757       };
13758     } catch (...) {
13759       {
13760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13761       };
13762     }
13763   }
13764   jresult = result;
13765
13766   //argout typemap for const std::string&
13767
13768   return jresult;
13769 }
13770
13771
13772 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
13773   unsigned int jresult ;
13774   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13775   Dali::Property::Index arg2 ;
13776   bool result;
13777
13778   arg1 = (Dali::Property::Key *)jarg1;
13779   arg2 = (Dali::Property::Index)jarg2;
13780   {
13781     try {
13782       result = (bool)(arg1)->operator ==(arg2);
13783     } catch (std::out_of_range& e) {
13784       {
13785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13786       };
13787     } catch (std::exception& e) {
13788       {
13789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13790       };
13791     } catch (...) {
13792       {
13793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13794       };
13795     }
13796   }
13797   jresult = result;
13798   return jresult;
13799 }
13800
13801
13802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
13803   unsigned int jresult ;
13804   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13805   Dali::Property::Key *arg2 = 0 ;
13806   bool result;
13807
13808   arg1 = (Dali::Property::Key *)jarg1;
13809   arg2 = (Dali::Property::Key *)jarg2;
13810   if (!arg2) {
13811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13812     return 0;
13813   }
13814   {
13815     try {
13816       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
13817     } catch (std::out_of_range& e) {
13818       {
13819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13820       };
13821     } catch (std::exception& e) {
13822       {
13823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13824       };
13825     } catch (...) {
13826       {
13827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13828       };
13829     }
13830   }
13831   jresult = result;
13832   return jresult;
13833 }
13834
13835
13836 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
13837   unsigned int jresult ;
13838   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13839   std::string *arg2 = 0 ;
13840   bool result;
13841
13842   arg1 = (Dali::Property::Key *)jarg1;
13843   if (!jarg2) {
13844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13845     return 0;
13846   }
13847   std::string arg2_str(jarg2);
13848   arg2 = &arg2_str;
13849   {
13850     try {
13851       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
13852     } catch (std::out_of_range& e) {
13853       {
13854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13855       };
13856     } catch (std::exception& e) {
13857       {
13858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13859       };
13860     } catch (...) {
13861       {
13862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13863       };
13864     }
13865   }
13866   jresult = result;
13867
13868   //argout typemap for const std::string&
13869
13870   return jresult;
13871 }
13872
13873
13874 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
13875   unsigned int jresult ;
13876   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13877   Dali::Property::Index arg2 ;
13878   bool result;
13879
13880   arg1 = (Dali::Property::Key *)jarg1;
13881   arg2 = (Dali::Property::Index)jarg2;
13882   {
13883     try {
13884       result = (bool)(arg1)->operator !=(arg2);
13885     } catch (std::out_of_range& e) {
13886       {
13887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13888       };
13889     } catch (std::exception& e) {
13890       {
13891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13892       };
13893     } catch (...) {
13894       {
13895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13896       };
13897     }
13898   }
13899   jresult = result;
13900   return jresult;
13901 }
13902
13903
13904 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
13905   unsigned int jresult ;
13906   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13907   Dali::Property::Key *arg2 = 0 ;
13908   bool result;
13909
13910   arg1 = (Dali::Property::Key *)jarg1;
13911   arg2 = (Dali::Property::Key *)jarg2;
13912   if (!arg2) {
13913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13914     return 0;
13915   }
13916   {
13917     try {
13918       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
13919     } catch (std::out_of_range& e) {
13920       {
13921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13922       };
13923     } catch (std::exception& e) {
13924       {
13925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13926       };
13927     } catch (...) {
13928       {
13929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13930       };
13931     }
13932   }
13933   jresult = result;
13934   return jresult;
13935 }
13936
13937
13938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
13939   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13940
13941   arg1 = (Dali::Property::Key *)jarg1;
13942   {
13943     try {
13944       delete arg1;
13945     } catch (std::out_of_range& e) {
13946       {
13947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13948       };
13949     } catch (std::exception& e) {
13950       {
13951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13952       };
13953     } catch (...) {
13954       {
13955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13956       };
13957     }
13958   }
13959 }
13960
13961
13962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
13963   void * jresult ;
13964   Dali::Property::Map *result = 0 ;
13965
13966   {
13967     try {
13968       result = (Dali::Property::Map *)new Dali::Property::Map();
13969     } catch (std::out_of_range& e) {
13970       {
13971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13972       };
13973     } catch (std::exception& e) {
13974       {
13975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13976       };
13977     } catch (...) {
13978       {
13979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13980       };
13981     }
13982   }
13983   jresult = (void *)result;
13984   return jresult;
13985 }
13986
13987
13988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
13989   void * jresult ;
13990   Dali::Property::Map *arg1 = 0 ;
13991   Dali::Property::Map *result = 0 ;
13992
13993   arg1 = (Dali::Property::Map *)jarg1;
13994   if (!arg1) {
13995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
13996     return 0;
13997   }
13998   {
13999     try {
14000       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
14001     } catch (std::out_of_range& e) {
14002       {
14003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14004       };
14005     } catch (std::exception& e) {
14006       {
14007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14008       };
14009     } catch (...) {
14010       {
14011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14012       };
14013     }
14014   }
14015   jresult = (void *)result;
14016   return jresult;
14017 }
14018
14019
14020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
14021   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14022
14023   arg1 = (Dali::Property::Map *)jarg1;
14024   {
14025     try {
14026       delete arg1;
14027     } catch (std::out_of_range& e) {
14028       {
14029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14030       };
14031     } catch (std::exception& e) {
14032       {
14033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14034       };
14035     } catch (...) {
14036       {
14037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14038       };
14039     }
14040   }
14041 }
14042
14043
14044 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
14045   unsigned long jresult ;
14046   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14047   Dali::Property::Map::SizeType result;
14048
14049   arg1 = (Dali::Property::Map *)jarg1;
14050   {
14051     try {
14052       result = ((Dali::Property::Map const *)arg1)->Count();
14053     } catch (std::out_of_range& e) {
14054       {
14055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14056       };
14057     } catch (std::exception& e) {
14058       {
14059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14060       };
14061     } catch (...) {
14062       {
14063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14064       };
14065     }
14066   }
14067   jresult = (unsigned long)result;
14068   return jresult;
14069 }
14070
14071
14072 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
14073   unsigned int jresult ;
14074   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14075   bool result;
14076
14077   arg1 = (Dali::Property::Map *)jarg1;
14078   {
14079     try {
14080       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
14081     } catch (std::out_of_range& e) {
14082       {
14083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14084       };
14085     } catch (std::exception& e) {
14086       {
14087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14088       };
14089     } catch (...) {
14090       {
14091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14092       };
14093     }
14094   }
14095   jresult = result;
14096   return jresult;
14097 }
14098
14099
14100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14101   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14102   char *arg2 = (char *) 0 ;
14103   Dali::Property::Value *arg3 = 0 ;
14104
14105   arg1 = (Dali::Property::Map *)jarg1;
14106   arg2 = (char *)jarg2;
14107   arg3 = (Dali::Property::Value *)jarg3;
14108   if (!arg3) {
14109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14110     return ;
14111   }
14112   {
14113     try {
14114       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
14115     } catch (std::out_of_range& e) {
14116       {
14117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14118       };
14119     } catch (std::exception& e) {
14120       {
14121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14122       };
14123     } catch (...) {
14124       {
14125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14126       };
14127     }
14128   }
14129 }
14130
14131
14132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14133   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14134   Dali::Property::Index arg2 ;
14135   Dali::Property::Value *arg3 = 0 ;
14136
14137   arg1 = (Dali::Property::Map *)jarg1;
14138   arg2 = (Dali::Property::Index)jarg2;
14139   arg3 = (Dali::Property::Value *)jarg3;
14140   if (!arg3) {
14141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14142     return ;
14143   }
14144   {
14145     try {
14146       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
14147     } catch (std::out_of_range& e) {
14148       {
14149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14150       };
14151     } catch (std::exception& e) {
14152       {
14153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14154       };
14155     } catch (...) {
14156       {
14157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14158       };
14159     }
14160   }
14161 }
14162
14163
14164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14165   void * jresult ;
14166   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14167   char *arg2 = (char *) 0 ;
14168   Dali::Property::Value *arg3 = 0 ;
14169   Dali::Property::Map *result = 0 ;
14170
14171   arg1 = (Dali::Property::Map *)jarg1;
14172   arg2 = (char *)jarg2;
14173   arg3 = (Dali::Property::Value *)jarg3;
14174   if (!arg3) {
14175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14176     return 0;
14177   }
14178   {
14179     try {
14180       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
14181     } catch (std::out_of_range& e) {
14182       {
14183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14184       };
14185     } catch (std::exception& e) {
14186       {
14187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14188       };
14189     } catch (...) {
14190       {
14191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14192       };
14193     }
14194   }
14195   jresult = (void *)result;
14196   return jresult;
14197 }
14198
14199
14200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14201   void * jresult ;
14202   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14203   Dali::Property::Index arg2 ;
14204   Dali::Property::Value *arg3 = 0 ;
14205   Dali::Property::Map *result = 0 ;
14206
14207   arg1 = (Dali::Property::Map *)jarg1;
14208   arg2 = (Dali::Property::Index)jarg2;
14209   arg3 = (Dali::Property::Value *)jarg3;
14210   if (!arg3) {
14211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14212     return 0;
14213   }
14214   {
14215     try {
14216       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
14217     } catch (std::out_of_range& e) {
14218       {
14219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14220       };
14221     } catch (std::exception& e) {
14222       {
14223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14224       };
14225     } catch (...) {
14226       {
14227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14228       };
14229     }
14230   }
14231   jresult = (void *)result;
14232   return jresult;
14233 }
14234
14235
14236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
14237   void * jresult ;
14238   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14239   Dali::Property::Map::SizeType arg2 ;
14240   Dali::Property::Value *result = 0 ;
14241
14242   arg1 = (Dali::Property::Map *)jarg1;
14243   arg2 = (Dali::Property::Map::SizeType)jarg2;
14244   {
14245     try {
14246       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
14247     } catch (std::out_of_range& e) {
14248       {
14249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14250       };
14251     } catch (std::exception& e) {
14252       {
14253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14254       };
14255     } catch (...) {
14256       {
14257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14258       };
14259     }
14260   }
14261   jresult = (void *)result;
14262   return jresult;
14263 }
14264
14265
14266 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
14267   char * jresult ;
14268   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14269   Dali::Property::Map::SizeType arg2 ;
14270   std::string *result = 0 ;
14271
14272   arg1 = (Dali::Property::Map *)jarg1;
14273   arg2 = (Dali::Property::Map::SizeType)jarg2;
14274   {
14275     try {
14276       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
14277     } catch (std::out_of_range& e) {
14278       {
14279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14280       };
14281     } catch (std::exception& e) {
14282       {
14283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14284       };
14285     } catch (...) {
14286       {
14287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14288       };
14289     }
14290   }
14291   jresult = SWIG_csharp_string_callback(result->c_str());
14292   return jresult;
14293 }
14294
14295
14296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
14297   void * jresult ;
14298   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14299   Dali::Property::Map::SizeType arg2 ;
14300   SwigValueWrapper< Dali::Property::Key > result;
14301
14302   arg1 = (Dali::Property::Map *)jarg1;
14303   arg2 = (Dali::Property::Map::SizeType)jarg2;
14304   {
14305     try {
14306       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
14307     } catch (std::out_of_range& e) {
14308       {
14309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14310       };
14311     } catch (std::exception& e) {
14312       {
14313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14314       };
14315     } catch (...) {
14316       {
14317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14318       };
14319     }
14320   }
14321   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
14322   return jresult;
14323 }
14324
14325
14326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
14327   void * jresult ;
14328   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14329   Dali::Property::Map::SizeType arg2 ;
14330   StringValuePair *result = 0 ;
14331
14332   arg1 = (Dali::Property::Map *)jarg1;
14333   arg2 = (Dali::Property::Map::SizeType)jarg2;
14334   {
14335     try {
14336       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
14337     } catch (std::out_of_range& e) {
14338       {
14339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14340       };
14341     } catch (std::exception& e) {
14342       {
14343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14344       };
14345     } catch (...) {
14346       {
14347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14348       };
14349     }
14350   }
14351   jresult = (void *)result;
14352   return jresult;
14353 }
14354
14355
14356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
14357   void * jresult ;
14358   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14359   char *arg2 = (char *) 0 ;
14360   Dali::Property::Value *result = 0 ;
14361
14362   arg1 = (Dali::Property::Map *)jarg1;
14363   arg2 = (char *)jarg2;
14364   {
14365     try {
14366       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
14367     } catch (std::out_of_range& e) {
14368       {
14369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14370       };
14371     } catch (std::exception& e) {
14372       {
14373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14374       };
14375     } catch (...) {
14376       {
14377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14378       };
14379     }
14380   }
14381   jresult = (void *)result;
14382   return jresult;
14383 }
14384
14385
14386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
14387   void * jresult ;
14388   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14389   Dali::Property::Index arg2 ;
14390   Dali::Property::Value *result = 0 ;
14391
14392   arg1 = (Dali::Property::Map *)jarg1;
14393   arg2 = (Dali::Property::Index)jarg2;
14394   {
14395     try {
14396       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
14397     } catch (std::out_of_range& e) {
14398       {
14399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14400       };
14401     } catch (std::exception& e) {
14402       {
14403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14404       };
14405     } catch (...) {
14406       {
14407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14408       };
14409     }
14410   }
14411   jresult = (void *)result;
14412   return jresult;
14413 }
14414
14415
14416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
14417   void * jresult ;
14418   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14419   Dali::Property::Index arg2 ;
14420   std::string *arg3 = 0 ;
14421   Dali::Property::Value *result = 0 ;
14422
14423   arg1 = (Dali::Property::Map *)jarg1;
14424   arg2 = (Dali::Property::Index)jarg2;
14425   if (!jarg3) {
14426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14427     return 0;
14428   }
14429   std::string arg3_str(jarg3);
14430   arg3 = &arg3_str;
14431   {
14432     try {
14433       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
14434     } catch (std::out_of_range& e) {
14435       {
14436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14437       };
14438     } catch (std::exception& e) {
14439       {
14440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14441       };
14442     } catch (...) {
14443       {
14444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14445       };
14446     }
14447   }
14448   jresult = (void *)result;
14449
14450   //argout typemap for const std::string&
14451
14452   return jresult;
14453 }
14454
14455
14456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
14457   void * jresult ;
14458   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14459   std::string *arg2 = 0 ;
14460   Dali::Property::Type arg3 ;
14461   Dali::Property::Value *result = 0 ;
14462
14463   arg1 = (Dali::Property::Map *)jarg1;
14464   if (!jarg2) {
14465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14466     return 0;
14467   }
14468   std::string arg2_str(jarg2);
14469   arg2 = &arg2_str;
14470   arg3 = (Dali::Property::Type)jarg3;
14471   {
14472     try {
14473       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
14474     } catch (std::out_of_range& e) {
14475       {
14476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14477       };
14478     } catch (std::exception& e) {
14479       {
14480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14481       };
14482     } catch (...) {
14483       {
14484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14485       };
14486     }
14487   }
14488   jresult = (void *)result;
14489
14490   //argout typemap for const std::string&
14491
14492   return jresult;
14493 }
14494
14495
14496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
14497   void * jresult ;
14498   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14499   Dali::Property::Index arg2 ;
14500   Dali::Property::Type arg3 ;
14501   Dali::Property::Value *result = 0 ;
14502
14503   arg1 = (Dali::Property::Map *)jarg1;
14504   arg2 = (Dali::Property::Index)jarg2;
14505   arg3 = (Dali::Property::Type)jarg3;
14506   {
14507     try {
14508       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
14509     } catch (std::out_of_range& e) {
14510       {
14511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14512       };
14513     } catch (std::exception& e) {
14514       {
14515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14516       };
14517     } catch (...) {
14518       {
14519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14520       };
14521     }
14522   }
14523   jresult = (void *)result;
14524   return jresult;
14525 }
14526
14527
14528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
14529   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14530
14531   arg1 = (Dali::Property::Map *)jarg1;
14532   {
14533     try {
14534       (arg1)->Clear();
14535     } catch (std::out_of_range& e) {
14536       {
14537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14538       };
14539     } catch (std::exception& e) {
14540       {
14541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14542       };
14543     } catch (...) {
14544       {
14545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14546       };
14547     }
14548   }
14549 }
14550
14551
14552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
14553   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14554   Dali::Property::Map *arg2 = 0 ;
14555
14556   arg1 = (Dali::Property::Map *)jarg1;
14557   arg2 = (Dali::Property::Map *)jarg2;
14558   if (!arg2) {
14559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14560     return ;
14561   }
14562   {
14563     try {
14564       (arg1)->Merge((Dali::Property::Map const &)*arg2);
14565     } catch (std::out_of_range& e) {
14566       {
14567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14568       };
14569     } catch (std::exception& e) {
14570       {
14571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14572       };
14573     } catch (...) {
14574       {
14575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14576       };
14577     }
14578   }
14579 }
14580
14581
14582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
14583   void * jresult ;
14584   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14585   std::string *arg2 = 0 ;
14586   Dali::Property::Value *result = 0 ;
14587
14588   arg1 = (Dali::Property::Map *)jarg1;
14589   if (!jarg2) {
14590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14591     return 0;
14592   }
14593   std::string arg2_str(jarg2);
14594   arg2 = &arg2_str;
14595   {
14596     try {
14597       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
14598     } catch (std::out_of_range& e) {
14599       {
14600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14601       };
14602     } catch (std::exception& e) {
14603       {
14604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14605       };
14606     } catch (...) {
14607       {
14608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14609       };
14610     }
14611   }
14612   jresult = (void *)result;
14613
14614   //argout typemap for const std::string&
14615
14616   return jresult;
14617 }
14618
14619
14620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
14621   void * jresult ;
14622   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14623   Dali::Property::Index arg2 ;
14624   Dali::Property::Value *result = 0 ;
14625
14626   arg1 = (Dali::Property::Map *)jarg1;
14627   arg2 = (Dali::Property::Index)jarg2;
14628   {
14629     try {
14630       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
14631     } catch (std::out_of_range& e) {
14632       {
14633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14634       };
14635     } catch (std::exception& e) {
14636       {
14637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14638       };
14639     } catch (...) {
14640       {
14641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14642       };
14643     }
14644   }
14645   jresult = (void *)result;
14646   return jresult;
14647 }
14648
14649
14650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
14651   void * jresult ;
14652   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14653   Dali::Property::Map *arg2 = 0 ;
14654   Dali::Property::Map *result = 0 ;
14655
14656   arg1 = (Dali::Property::Map *)jarg1;
14657   arg2 = (Dali::Property::Map *)jarg2;
14658   if (!arg2) {
14659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14660     return 0;
14661   }
14662   {
14663     try {
14664       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
14665     } catch (std::out_of_range& e) {
14666       {
14667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14668       };
14669     } catch (std::exception& e) {
14670       {
14671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14672       };
14673     } catch (...) {
14674       {
14675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14676       };
14677     }
14678   }
14679   jresult = (void *)result;
14680   return jresult;
14681 }
14682
14683
14684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
14685   void * jresult ;
14686   Dali::Property::Value *result = 0 ;
14687
14688   {
14689     try {
14690       result = (Dali::Property::Value *)new Dali::Property::Value();
14691     } catch (std::out_of_range& e) {
14692       {
14693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14694       };
14695     } catch (std::exception& e) {
14696       {
14697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14698       };
14699     } catch (...) {
14700       {
14701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14702       };
14703     }
14704   }
14705   jresult = (void *)result;
14706   return jresult;
14707 }
14708
14709
14710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
14711   void * jresult ;
14712   bool arg1 ;
14713   Dali::Property::Value *result = 0 ;
14714
14715   arg1 = jarg1 ? true : false;
14716   {
14717     try {
14718       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14719     } catch (std::out_of_range& e) {
14720       {
14721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14722       };
14723     } catch (std::exception& e) {
14724       {
14725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14726       };
14727     } catch (...) {
14728       {
14729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14730       };
14731     }
14732   }
14733   jresult = (void *)result;
14734   return jresult;
14735 }
14736
14737
14738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
14739   void * jresult ;
14740   int arg1 ;
14741   Dali::Property::Value *result = 0 ;
14742
14743   arg1 = (int)jarg1;
14744   {
14745     try {
14746       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14747     } catch (std::out_of_range& e) {
14748       {
14749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14750       };
14751     } catch (std::exception& e) {
14752       {
14753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14754       };
14755     } catch (...) {
14756       {
14757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14758       };
14759     }
14760   }
14761   jresult = (void *)result;
14762   return jresult;
14763 }
14764
14765
14766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
14767   void * jresult ;
14768   float arg1 ;
14769   Dali::Property::Value *result = 0 ;
14770
14771   arg1 = (float)jarg1;
14772   {
14773     try {
14774       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14775     } catch (std::out_of_range& e) {
14776       {
14777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14778       };
14779     } catch (std::exception& e) {
14780       {
14781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14782       };
14783     } catch (...) {
14784       {
14785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14786       };
14787     }
14788   }
14789   jresult = (void *)result;
14790   return jresult;
14791 }
14792
14793
14794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
14795   void * jresult ;
14796   Dali::Vector2 *arg1 = 0 ;
14797   Dali::Property::Value *result = 0 ;
14798
14799   arg1 = (Dali::Vector2 *)jarg1;
14800   if (!arg1) {
14801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
14802     return 0;
14803   }
14804   {
14805     try {
14806       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
14807     } catch (std::out_of_range& e) {
14808       {
14809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14810       };
14811     } catch (std::exception& e) {
14812       {
14813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14814       };
14815     } catch (...) {
14816       {
14817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14818       };
14819     }
14820   }
14821   jresult = (void *)result;
14822   return jresult;
14823 }
14824
14825
14826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
14827   void * jresult ;
14828   Dali::Vector3 *arg1 = 0 ;
14829   Dali::Property::Value *result = 0 ;
14830
14831   arg1 = (Dali::Vector3 *)jarg1;
14832   if (!arg1) {
14833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14834     return 0;
14835   }
14836   {
14837     try {
14838       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
14839     } catch (std::out_of_range& e) {
14840       {
14841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14842       };
14843     } catch (std::exception& e) {
14844       {
14845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14846       };
14847     } catch (...) {
14848       {
14849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14850       };
14851     }
14852   }
14853   jresult = (void *)result;
14854   return jresult;
14855 }
14856
14857
14858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
14859   void * jresult ;
14860   Dali::Vector4 *arg1 = 0 ;
14861   Dali::Property::Value *result = 0 ;
14862
14863   arg1 = (Dali::Vector4 *)jarg1;
14864   if (!arg1) {
14865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
14866     return 0;
14867   }
14868   {
14869     try {
14870       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
14871     } catch (std::out_of_range& e) {
14872       {
14873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14874       };
14875     } catch (std::exception& e) {
14876       {
14877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14878       };
14879     } catch (...) {
14880       {
14881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14882       };
14883     }
14884   }
14885   jresult = (void *)result;
14886   return jresult;
14887 }
14888
14889
14890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
14891   void * jresult ;
14892   Dali::Matrix3 *arg1 = 0 ;
14893   Dali::Property::Value *result = 0 ;
14894
14895   arg1 = (Dali::Matrix3 *)jarg1;
14896   if (!arg1) {
14897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
14898     return 0;
14899   }
14900   {
14901     try {
14902       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
14903     } catch (std::out_of_range& e) {
14904       {
14905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14906       };
14907     } catch (std::exception& e) {
14908       {
14909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14910       };
14911     } catch (...) {
14912       {
14913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14914       };
14915     }
14916   }
14917   jresult = (void *)result;
14918   return jresult;
14919 }
14920
14921
14922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
14923   void * jresult ;
14924   Dali::Matrix *arg1 = 0 ;
14925   Dali::Property::Value *result = 0 ;
14926
14927   arg1 = (Dali::Matrix *)jarg1;
14928   if (!arg1) {
14929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
14930     return 0;
14931   }
14932   {
14933     try {
14934       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
14935     } catch (std::out_of_range& e) {
14936       {
14937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14938       };
14939     } catch (std::exception& e) {
14940       {
14941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14942       };
14943     } catch (...) {
14944       {
14945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14946       };
14947     }
14948   }
14949   jresult = (void *)result;
14950   return jresult;
14951 }
14952
14953
14954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
14955   void * jresult ;
14956   Dali::Rect< int > *arg1 = 0 ;
14957   Dali::Property::Value *result = 0 ;
14958
14959   arg1 = (Dali::Rect< int > *)jarg1;
14960   if (!arg1) {
14961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
14962     return 0;
14963   }
14964   {
14965     try {
14966       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
14967     } catch (std::out_of_range& e) {
14968       {
14969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14970       };
14971     } catch (std::exception& e) {
14972       {
14973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14974       };
14975     } catch (...) {
14976       {
14977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14978       };
14979     }
14980   }
14981   jresult = (void *)result;
14982   return jresult;
14983 }
14984
14985
14986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
14987   void * jresult ;
14988   Dali::AngleAxis *arg1 = 0 ;
14989   Dali::Property::Value *result = 0 ;
14990
14991   arg1 = (Dali::AngleAxis *)jarg1;
14992   if (!arg1) {
14993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14994     return 0;
14995   }
14996   {
14997     try {
14998       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
14999     } catch (std::out_of_range& e) {
15000       {
15001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15002       };
15003     } catch (std::exception& e) {
15004       {
15005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15006       };
15007     } catch (...) {
15008       {
15009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15010       };
15011     }
15012   }
15013   jresult = (void *)result;
15014   return jresult;
15015 }
15016
15017
15018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
15019   void * jresult ;
15020   Dali::Quaternion *arg1 = 0 ;
15021   Dali::Property::Value *result = 0 ;
15022
15023   arg1 = (Dali::Quaternion *)jarg1;
15024   if (!arg1) {
15025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
15026     return 0;
15027   }
15028   {
15029     try {
15030       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
15031     } catch (std::out_of_range& e) {
15032       {
15033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15034       };
15035     } catch (std::exception& e) {
15036       {
15037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15038       };
15039     } catch (...) {
15040       {
15041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15042       };
15043     }
15044   }
15045   jresult = (void *)result;
15046   return jresult;
15047 }
15048
15049
15050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
15051   void * jresult ;
15052   std::string *arg1 = 0 ;
15053   Dali::Property::Value *result = 0 ;
15054
15055   if (!jarg1) {
15056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15057     return 0;
15058   }
15059   std::string arg1_str(jarg1);
15060   arg1 = &arg1_str;
15061   {
15062     try {
15063       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
15064     } catch (std::out_of_range& e) {
15065       {
15066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15067       };
15068     } catch (std::exception& e) {
15069       {
15070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15071       };
15072     } catch (...) {
15073       {
15074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15075       };
15076     }
15077   }
15078   jresult = (void *)result;
15079
15080   //argout typemap for const std::string&
15081
15082   return jresult;
15083 }
15084
15085
15086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
15087   void * jresult ;
15088   Dali::Property::Array *arg1 = 0 ;
15089   Dali::Property::Value *result = 0 ;
15090
15091   arg1 = (Dali::Property::Array *)jarg1;
15092   if (!arg1) {
15093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15094     return 0;
15095   }
15096   {
15097     try {
15098       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15099     } catch (std::out_of_range& e) {
15100       {
15101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15102       };
15103     } catch (std::exception& e) {
15104       {
15105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15106       };
15107     } catch (...) {
15108       {
15109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15110       };
15111     }
15112   }
15113   jresult = (void *)result;
15114   return jresult;
15115 }
15116
15117
15118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
15119   void * jresult ;
15120   Dali::Property::Map *arg1 = 0 ;
15121   Dali::Property::Value *result = 0 ;
15122
15123   arg1 = (Dali::Property::Map *)jarg1;
15124   if (!arg1) {
15125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15126     return 0;
15127   }
15128   {
15129     try {
15130       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15131     } catch (std::out_of_range& e) {
15132       {
15133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15134       };
15135     } catch (std::exception& e) {
15136       {
15137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15138       };
15139     } catch (...) {
15140       {
15141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15142       };
15143     }
15144   }
15145   jresult = (void *)result;
15146   return jresult;
15147 }
15148
15149
15150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(int jarg1) {
15151   void * jresult ;
15152   Dali::Property::Type arg1 ;
15153   Dali::Property::Value *result = 0 ;
15154
15155   arg1 = (Dali::Property::Type)jarg1;
15156   {
15157     try {
15158       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
15159     } catch (std::out_of_range& e) {
15160       {
15161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15162       };
15163     } catch (std::exception& e) {
15164       {
15165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15166       };
15167     } catch (...) {
15168       {
15169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15170       };
15171     }
15172   }
15173   jresult = (void *)result;
15174   return jresult;
15175 }
15176
15177
15178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(void * jarg1) {
15179   void * jresult ;
15180   Dali::Property::Value *arg1 = 0 ;
15181   Dali::Property::Value *result = 0 ;
15182
15183   arg1 = (Dali::Property::Value *)jarg1;
15184   if (!arg1) {
15185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15186     return 0;
15187   }
15188   {
15189     try {
15190       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
15191     } catch (std::out_of_range& e) {
15192       {
15193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15194       };
15195     } catch (std::exception& e) {
15196       {
15197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15198       };
15199     } catch (...) {
15200       {
15201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15202       };
15203     }
15204   }
15205   jresult = (void *)result;
15206   return jresult;
15207 }
15208
15209
15210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
15211   void * jresult ;
15212   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15213   Dali::Property::Value *arg2 = 0 ;
15214   Dali::Property::Value *result = 0 ;
15215
15216   arg1 = (Dali::Property::Value *)jarg1;
15217   arg2 = (Dali::Property::Value *)jarg2;
15218   if (!arg2) {
15219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15220     return 0;
15221   }
15222   {
15223     try {
15224       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
15225     } catch (std::out_of_range& e) {
15226       {
15227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15228       };
15229     } catch (std::exception& e) {
15230       {
15231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15232       };
15233     } catch (...) {
15234       {
15235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15236       };
15237     }
15238   }
15239   jresult = (void *)result;
15240   return jresult;
15241 }
15242
15243
15244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
15245   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15246
15247   arg1 = (Dali::Property::Value *)jarg1;
15248   {
15249     try {
15250       delete arg1;
15251     } catch (std::out_of_range& e) {
15252       {
15253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15254       };
15255     } catch (std::exception& e) {
15256       {
15257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15258       };
15259     } catch (...) {
15260       {
15261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15262       };
15263     }
15264   }
15265 }
15266
15267
15268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
15269   int jresult ;
15270   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15271   Dali::Property::Type result;
15272
15273   arg1 = (Dali::Property::Value *)jarg1;
15274   {
15275     try {
15276       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
15277     } catch (std::out_of_range& e) {
15278       {
15279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15280       };
15281     } catch (std::exception& e) {
15282       {
15283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15284       };
15285     } catch (...) {
15286       {
15287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15288       };
15289     }
15290   }
15291   jresult = (int)result;
15292   return jresult;
15293 }
15294
15295
15296 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
15297   unsigned int jresult ;
15298   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15299   bool *arg2 = 0 ;
15300   bool result;
15301
15302   arg1 = (Dali::Property::Value *)jarg1;
15303   arg2 = (bool *)jarg2;
15304   {
15305     try {
15306       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15307     } catch (std::out_of_range& e) {
15308       {
15309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15310       };
15311     } catch (std::exception& e) {
15312       {
15313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15314       };
15315     } catch (...) {
15316       {
15317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15318       };
15319     }
15320   }
15321   jresult = result;
15322   return jresult;
15323 }
15324
15325
15326 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
15327   unsigned int jresult ;
15328   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15329   float *arg2 = 0 ;
15330   bool result;
15331
15332   arg1 = (Dali::Property::Value *)jarg1;
15333   arg2 = (float *)jarg2;
15334   {
15335     try {
15336       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15337     } catch (std::out_of_range& e) {
15338       {
15339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15340       };
15341     } catch (std::exception& e) {
15342       {
15343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15344       };
15345     } catch (...) {
15346       {
15347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15348       };
15349     }
15350   }
15351   jresult = result;
15352   return jresult;
15353 }
15354
15355
15356 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
15357   unsigned int jresult ;
15358   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15359   int *arg2 = 0 ;
15360   bool result;
15361
15362   arg1 = (Dali::Property::Value *)jarg1;
15363   arg2 = (int *)jarg2;
15364   {
15365     try {
15366       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15367     } catch (std::out_of_range& e) {
15368       {
15369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15370       };
15371     } catch (std::exception& e) {
15372       {
15373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15374       };
15375     } catch (...) {
15376       {
15377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15378       };
15379     }
15380   }
15381   jresult = result;
15382   return jresult;
15383 }
15384
15385
15386 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
15387   unsigned int jresult ;
15388   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15389   Dali::Rect< int > *arg2 = 0 ;
15390   bool result;
15391
15392   arg1 = (Dali::Property::Value *)jarg1;
15393   arg2 = (Dali::Rect< int > *)jarg2;
15394   if (!arg2) {
15395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
15396     return 0;
15397   }
15398   {
15399     try {
15400       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15401     } catch (std::out_of_range& e) {
15402       {
15403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15404       };
15405     } catch (std::exception& e) {
15406       {
15407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15408       };
15409     } catch (...) {
15410       {
15411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15412       };
15413     }
15414   }
15415   jresult = result;
15416   return jresult;
15417 }
15418
15419
15420 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
15421   unsigned int jresult ;
15422   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15423   Dali::Vector2 *arg2 = 0 ;
15424   bool result;
15425
15426   arg1 = (Dali::Property::Value *)jarg1;
15427   arg2 = (Dali::Vector2 *)jarg2;
15428   if (!arg2) {
15429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
15430     return 0;
15431   }
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_6(void * jarg1, void * jarg2) {
15455   unsigned int jresult ;
15456   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15457   Dali::Vector3 *arg2 = 0 ;
15458   bool result;
15459
15460   arg1 = (Dali::Property::Value *)jarg1;
15461   arg2 = (Dali::Vector3 *)jarg2;
15462   if (!arg2) {
15463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
15464     return 0;
15465   }
15466   {
15467     try {
15468       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15469     } catch (std::out_of_range& e) {
15470       {
15471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15472       };
15473     } catch (std::exception& e) {
15474       {
15475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15476       };
15477     } catch (...) {
15478       {
15479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15480       };
15481     }
15482   }
15483   jresult = result;
15484   return jresult;
15485 }
15486
15487
15488 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
15489   unsigned int jresult ;
15490   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15491   Dali::Vector4 *arg2 = 0 ;
15492   bool result;
15493
15494   arg1 = (Dali::Property::Value *)jarg1;
15495   arg2 = (Dali::Vector4 *)jarg2;
15496   if (!arg2) {
15497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
15498     return 0;
15499   }
15500   {
15501     try {
15502       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15503     } catch (std::out_of_range& e) {
15504       {
15505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15506       };
15507     } catch (std::exception& e) {
15508       {
15509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15510       };
15511     } catch (...) {
15512       {
15513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15514       };
15515     }
15516   }
15517   jresult = result;
15518   return jresult;
15519 }
15520
15521
15522 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
15523   unsigned int jresult ;
15524   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15525   Dali::Matrix3 *arg2 = 0 ;
15526   bool result;
15527
15528   arg1 = (Dali::Property::Value *)jarg1;
15529   arg2 = (Dali::Matrix3 *)jarg2;
15530   if (!arg2) {
15531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
15532     return 0;
15533   }
15534   {
15535     try {
15536       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15537     } catch (std::out_of_range& e) {
15538       {
15539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15540       };
15541     } catch (std::exception& e) {
15542       {
15543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15544       };
15545     } catch (...) {
15546       {
15547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15548       };
15549     }
15550   }
15551   jresult = result;
15552   return jresult;
15553 }
15554
15555
15556 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
15557   unsigned int jresult ;
15558   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15559   Dali::Matrix *arg2 = 0 ;
15560   bool result;
15561
15562   arg1 = (Dali::Property::Value *)jarg1;
15563   arg2 = (Dali::Matrix *)jarg2;
15564   if (!arg2) {
15565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
15566     return 0;
15567   }
15568   {
15569     try {
15570       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15571     } catch (std::out_of_range& e) {
15572       {
15573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15574       };
15575     } catch (std::exception& e) {
15576       {
15577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15578       };
15579     } catch (...) {
15580       {
15581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15582       };
15583     }
15584   }
15585   jresult = result;
15586   return jresult;
15587 }
15588
15589
15590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
15591   unsigned int jresult ;
15592   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15593   Dali::AngleAxis *arg2 = 0 ;
15594   bool result;
15595
15596   arg1 = (Dali::Property::Value *)jarg1;
15597   arg2 = (Dali::AngleAxis *)jarg2;
15598   if (!arg2) {
15599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
15600     return 0;
15601   }
15602   {
15603     try {
15604       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15605     } catch (std::out_of_range& e) {
15606       {
15607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15608       };
15609     } catch (std::exception& e) {
15610       {
15611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15612       };
15613     } catch (...) {
15614       {
15615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15616       };
15617     }
15618   }
15619   jresult = result;
15620   return jresult;
15621 }
15622
15623
15624 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
15625   unsigned int jresult ;
15626   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15627   Dali::Quaternion *arg2 = 0 ;
15628   bool result;
15629
15630   arg1 = (Dali::Property::Value *)jarg1;
15631   arg2 = (Dali::Quaternion *)jarg2;
15632   if (!arg2) {
15633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
15634     return 0;
15635   }
15636   {
15637     try {
15638       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15639     } catch (std::out_of_range& e) {
15640       {
15641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15642       };
15643     } catch (std::exception& e) {
15644       {
15645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15646       };
15647     } catch (...) {
15648       {
15649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15650       };
15651     }
15652   }
15653   jresult = result;
15654   return jresult;
15655 }
15656
15657
15658 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
15659   unsigned int jresult ;
15660   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15661   std::string *arg2 = 0 ;
15662   bool result;
15663
15664   arg1 = (Dali::Property::Value *)jarg1;
15665
15666   //typemap in
15667   std::string temp;
15668   arg2 = &temp;
15669
15670   {
15671     try {
15672       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15673     } catch (std::out_of_range& e) {
15674       {
15675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15676       };
15677     } catch (std::exception& e) {
15678       {
15679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15680       };
15681     } catch (...) {
15682       {
15683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15684       };
15685     }
15686   }
15687   jresult = result;
15688
15689   //Typemap argout in c++ file.
15690   //This will convert c++ string to c# string
15691   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
15692
15693   return jresult;
15694 }
15695
15696
15697 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
15698   unsigned int jresult ;
15699   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15700   Dali::Property::Array *arg2 = 0 ;
15701   bool result;
15702
15703   arg1 = (Dali::Property::Value *)jarg1;
15704   arg2 = (Dali::Property::Array *)jarg2;
15705   if (!arg2) {
15706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15707     return 0;
15708   }
15709   {
15710     try {
15711       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15712     } catch (std::out_of_range& e) {
15713       {
15714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15715       };
15716     } catch (std::exception& e) {
15717       {
15718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15719       };
15720     } catch (...) {
15721       {
15722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15723       };
15724     }
15725   }
15726   jresult = result;
15727   return jresult;
15728 }
15729
15730
15731 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
15732   unsigned int jresult ;
15733   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15734   Dali::Property::Map *arg2 = 0 ;
15735   bool result;
15736
15737   arg1 = (Dali::Property::Value *)jarg1;
15738   arg2 = (Dali::Property::Map *)jarg2;
15739   if (!arg2) {
15740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15741     return 0;
15742   }
15743   {
15744     try {
15745       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15746     } catch (std::out_of_range& e) {
15747       {
15748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15749       };
15750     } catch (std::exception& e) {
15751       {
15752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15753       };
15754     } catch (...) {
15755       {
15756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15757       };
15758     }
15759   }
15760   jresult = result;
15761   return jresult;
15762 }
15763
15764
15765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
15766   void * jresult ;
15767   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15768   Dali::Property::Array *result = 0 ;
15769
15770   arg1 = (Dali::Property::Value *)jarg1;
15771   {
15772     try {
15773       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
15774     } catch (std::out_of_range& e) {
15775       {
15776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15777       };
15778     } catch (std::exception& e) {
15779       {
15780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15781       };
15782     } catch (...) {
15783       {
15784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15785       };
15786     }
15787   }
15788   jresult = (void *)result;
15789   return jresult;
15790 }
15791
15792
15793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
15794   void * jresult ;
15795   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15796   Dali::Property::Map *result = 0 ;
15797
15798   arg1 = (Dali::Property::Value *)jarg1;
15799   {
15800     try {
15801       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
15802     } catch (std::out_of_range& e) {
15803       {
15804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15805       };
15806     } catch (std::exception& e) {
15807       {
15808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15809       };
15810     } catch (...) {
15811       {
15812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15813       };
15814     }
15815   }
15816   jresult = (void *)result;
15817   return jresult;
15818 }
15819
15820
15821 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
15822   char * jresult ;
15823   Dali::Property::Type arg1 ;
15824   char *result = 0 ;
15825
15826   arg1 = (Dali::Property::Type)jarg1;
15827   {
15828     try {
15829       result = (char *)Dali::PropertyTypes::GetName(arg1);
15830     } catch (std::out_of_range& e) {
15831       {
15832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15833       };
15834     } catch (std::exception& e) {
15835       {
15836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15837       };
15838     } catch (...) {
15839       {
15840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15841       };
15842     }
15843   }
15844   jresult = SWIG_csharp_string_callback((const char *)result);
15845   return jresult;
15846 }
15847
15848
15849 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
15850   unsigned int jresult ;
15851   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15852   std::string *arg2 = 0 ;
15853   Dali::Property::Map *arg3 = 0 ;
15854   bool result;
15855
15856   arg1 = (Dali::BaseObject *)jarg1;
15857   if (!jarg2) {
15858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15859     return 0;
15860   }
15861   std::string arg2_str(jarg2);
15862   arg2 = &arg2_str;
15863   arg3 = (Dali::Property::Map *)jarg3;
15864   if (!arg3) {
15865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15866     return 0;
15867   }
15868   {
15869     try {
15870       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
15871     } catch (std::out_of_range& e) {
15872       {
15873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15874       };
15875     } catch (std::exception& e) {
15876       {
15877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15878       };
15879     } catch (...) {
15880       {
15881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15882       };
15883     }
15884   }
15885   jresult = result;
15886
15887   //argout typemap for const std::string&
15888
15889   return jresult;
15890 }
15891
15892
15893 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
15894   char * jresult ;
15895   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15896   std::string *result = 0 ;
15897
15898   arg1 = (Dali::BaseObject *)jarg1;
15899   {
15900     try {
15901       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
15902     } catch (std::out_of_range& e) {
15903       {
15904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15905       };
15906     } catch (std::exception& e) {
15907       {
15908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15909       };
15910     } catch (...) {
15911       {
15912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15913       };
15914     }
15915   }
15916   jresult = SWIG_csharp_string_callback(result->c_str());
15917   return jresult;
15918 }
15919
15920
15921 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
15922   unsigned int jresult ;
15923   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15924   Dali::TypeInfo *arg2 = 0 ;
15925   bool result;
15926
15927   arg1 = (Dali::BaseObject *)jarg1;
15928   arg2 = (Dali::TypeInfo *)jarg2;
15929   if (!arg2) {
15930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
15931     return 0;
15932   }
15933   {
15934     try {
15935       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
15936     } catch (std::out_of_range& e) {
15937       {
15938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15939       };
15940     } catch (std::exception& e) {
15941       {
15942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15943       };
15944     } catch (...) {
15945       {
15946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15947       };
15948     }
15949   }
15950   jresult = result;
15951   return jresult;
15952 }
15953
15954
15955 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
15956   unsigned int jresult ;
15957   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15958   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
15959   std::string *arg3 = 0 ;
15960   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
15961   bool result;
15962
15963   arg1 = (Dali::BaseObject *)jarg1;
15964   arg2 = (ConnectionTrackerInterface *)jarg2;
15965   if (!jarg3) {
15966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15967     return 0;
15968   }
15969   std::string arg3_str(jarg3);
15970   arg3 = &arg3_str;
15971   arg4 = (FunctorDelegate *)jarg4;
15972   {
15973     try {
15974       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
15975     } catch (std::out_of_range& e) {
15976       {
15977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15978       };
15979     } catch (std::exception& e) {
15980       {
15981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15982       };
15983     } catch (...) {
15984       {
15985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15986       };
15987     }
15988   }
15989   jresult = result;
15990
15991   //argout typemap for const std::string&
15992
15993   return jresult;
15994 }
15995
15996
15997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
15998   void * jresult ;
15999   Dali::BaseHandle *arg1 = 0 ;
16000   Dali::BaseObject *result = 0 ;
16001
16002   arg1 = (Dali::BaseHandle *)jarg1;
16003   if (!arg1) {
16004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16005     return 0;
16006   }
16007   {
16008     try {
16009       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
16010     } catch (std::out_of_range& e) {
16011       {
16012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16013       };
16014     } catch (std::exception& e) {
16015       {
16016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16017       };
16018     } catch (...) {
16019       {
16020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16021       };
16022     }
16023   }
16024   jresult = (void *)result;
16025   return jresult;
16026 }
16027
16028
16029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
16030   void * jresult ;
16031   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16032   Dali::BaseHandle *result = 0 ;
16033
16034   arg1 = (Dali::BaseObject *)jarg1;
16035   {
16036     try {
16037       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
16038     } catch (std::out_of_range& e) {
16039       {
16040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16041       };
16042     } catch (std::exception& e) {
16043       {
16044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16045       };
16046     } catch (...) {
16047       {
16048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16049       };
16050     }
16051   }
16052   jresult = (void *)result;
16053   return jresult;
16054 }
16055
16056
16057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
16058   void * jresult ;
16059   Dali::BaseHandle *result = 0 ;
16060
16061   {
16062     try {
16063       result = (Dali::BaseHandle *)new Dali::BaseHandle();
16064     } catch (std::out_of_range& e) {
16065       {
16066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16067       };
16068     } catch (std::exception& e) {
16069       {
16070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16071       };
16072     } catch (...) {
16073       {
16074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16075       };
16076     }
16077   }
16078   jresult = (void *)result;
16079   return jresult;
16080 }
16081
16082
16083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
16084   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16085
16086   arg1 = (Dali::BaseHandle *)jarg1;
16087   {
16088     try {
16089       delete arg1;
16090     } catch (std::out_of_range& e) {
16091       {
16092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16093       };
16094     } catch (std::exception& e) {
16095       {
16096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16097       };
16098     } catch (...) {
16099       {
16100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16101       };
16102     }
16103   }
16104 }
16105
16106
16107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
16108   void * jresult ;
16109   Dali::BaseHandle *arg1 = 0 ;
16110   Dali::BaseHandle *result = 0 ;
16111
16112   arg1 = (Dali::BaseHandle *)jarg1;
16113   if (!arg1) {
16114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16115     return 0;
16116   }
16117   {
16118     try {
16119       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
16120     } catch (std::out_of_range& e) {
16121       {
16122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16123       };
16124     } catch (std::exception& e) {
16125       {
16126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16127       };
16128     } catch (...) {
16129       {
16130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16131       };
16132     }
16133   }
16134   jresult = (void *)result;
16135   return jresult;
16136 }
16137
16138
16139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
16140   void * jresult ;
16141   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16142   Dali::BaseHandle *arg2 = 0 ;
16143   Dali::BaseHandle *result = 0 ;
16144
16145   arg1 = (Dali::BaseHandle *)jarg1;
16146   arg2 = (Dali::BaseHandle *)jarg2;
16147   if (!arg2) {
16148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16149     return 0;
16150   }
16151   {
16152     try {
16153       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
16154     } catch (std::out_of_range& e) {
16155       {
16156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16157       };
16158     } catch (std::exception& e) {
16159       {
16160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16161       };
16162     } catch (...) {
16163       {
16164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16165       };
16166     }
16167   }
16168   jresult = (void *)result;
16169   return jresult;
16170 }
16171
16172
16173 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
16174   unsigned int jresult ;
16175   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16176   std::string *arg2 = 0 ;
16177   Dali::Property::Map *arg3 = 0 ;
16178   bool result;
16179
16180   arg1 = (Dali::BaseHandle *)jarg1;
16181   if (!jarg2) {
16182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16183     return 0;
16184   }
16185   std::string arg2_str(jarg2);
16186   arg2 = &arg2_str;
16187   arg3 = (Dali::Property::Map *)jarg3;
16188   if (!arg3) {
16189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16190     return 0;
16191   }
16192   {
16193     try {
16194       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
16195     } catch (std::out_of_range& e) {
16196       {
16197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16198       };
16199     } catch (std::exception& e) {
16200       {
16201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16202       };
16203     } catch (...) {
16204       {
16205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16206       };
16207     }
16208   }
16209   jresult = result;
16210
16211   //argout typemap for const std::string&
16212
16213   return jresult;
16214 }
16215
16216
16217 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
16218   char * jresult ;
16219   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16220   std::string *result = 0 ;
16221
16222   arg1 = (Dali::BaseHandle *)jarg1;
16223   {
16224     try {
16225       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
16226     } catch (std::out_of_range& e) {
16227       {
16228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16229       };
16230     } catch (std::exception& e) {
16231       {
16232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16233       };
16234     } catch (...) {
16235       {
16236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16237       };
16238     }
16239   }
16240   jresult = SWIG_csharp_string_callback(result->c_str());
16241   return jresult;
16242 }
16243
16244
16245 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
16246   unsigned int jresult ;
16247   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16248   Dali::TypeInfo *arg2 = 0 ;
16249   bool result;
16250
16251   arg1 = (Dali::BaseHandle *)jarg1;
16252   arg2 = (Dali::TypeInfo *)jarg2;
16253   if (!arg2) {
16254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
16255     return 0;
16256   }
16257   {
16258     try {
16259       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
16260     } catch (std::out_of_range& e) {
16261       {
16262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16263       };
16264     } catch (std::exception& e) {
16265       {
16266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16267       };
16268     } catch (...) {
16269       {
16270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16271       };
16272     }
16273   }
16274   jresult = result;
16275   return jresult;
16276 }
16277
16278
16279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
16280   void * jresult ;
16281   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16282   Dali::BaseObject *result = 0 ;
16283
16284   arg1 = (Dali::BaseHandle *)jarg1;
16285   {
16286     try {
16287       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
16288     } catch (std::out_of_range& e) {
16289       {
16290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16291       };
16292     } catch (std::exception& e) {
16293       {
16294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16295       };
16296     } catch (...) {
16297       {
16298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16299       };
16300     }
16301   }
16302   jresult = (void *)result;
16303   return jresult;
16304 }
16305
16306
16307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
16308   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16309
16310   arg1 = (Dali::BaseHandle *)jarg1;
16311   {
16312     try {
16313       (arg1)->Reset();
16314     } catch (std::out_of_range& e) {
16315       {
16316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16317       };
16318     } catch (std::exception& e) {
16319       {
16320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16321       };
16322     } catch (...) {
16323       {
16324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16325       };
16326     }
16327   }
16328 }
16329
16330
16331 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
16332   unsigned int jresult ;
16333   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16334   Dali::BaseHandle *arg2 = 0 ;
16335   bool result;
16336
16337   arg1 = (Dali::BaseHandle *)jarg1;
16338   arg2 = (Dali::BaseHandle *)jarg2;
16339   if (!arg2) {
16340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16341     return 0;
16342   }
16343   {
16344     try {
16345       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
16346     } catch (std::out_of_range& e) {
16347       {
16348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16349       };
16350     } catch (std::exception& e) {
16351       {
16352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16353       };
16354     } catch (...) {
16355       {
16356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16357       };
16358     }
16359   }
16360   jresult = result;
16361   return jresult;
16362 }
16363
16364
16365 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
16366   unsigned int jresult ;
16367   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16368   Dali::BaseHandle *arg2 = 0 ;
16369   bool result;
16370
16371   arg1 = (Dali::BaseHandle *)jarg1;
16372   arg2 = (Dali::BaseHandle *)jarg2;
16373   if (!arg2) {
16374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16375     return 0;
16376   }
16377   {
16378     try {
16379       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
16380     } catch (std::out_of_range& e) {
16381       {
16382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16383       };
16384     } catch (std::exception& e) {
16385       {
16386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16387       };
16388     } catch (...) {
16389       {
16390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16391       };
16392     }
16393   }
16394   jresult = result;
16395   return jresult;
16396 }
16397
16398
16399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
16400   void * jresult ;
16401   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16402   Dali::RefObject *result = 0 ;
16403
16404   arg1 = (Dali::BaseHandle *)jarg1;
16405   {
16406     try {
16407       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
16408     } catch (std::out_of_range& e) {
16409       {
16410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16411       };
16412     } catch (std::exception& e) {
16413       {
16414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16415       };
16416     } catch (...) {
16417       {
16418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16419       };
16420     }
16421   }
16422   jresult = (void *)result;
16423   return jresult;
16424 }
16425
16426
16427 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
16428   unsigned int jresult ;
16429   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16430   bool result;
16431
16432   arg1 = (Dali::BaseHandle *)jarg1;
16433   {
16434     try {
16435       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
16436     } catch (std::out_of_range& e) {
16437       {
16438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16439       };
16440     } catch (std::exception& e) {
16441       {
16442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16443       };
16444     } catch (...) {
16445       {
16446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16447       };
16448     }
16449   }
16450   jresult = result;
16451   return jresult;
16452 }
16453
16454
16455 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
16456   unsigned int jresult ;
16457   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16458   Dali::BaseHandle *arg2 = 0 ;
16459   bool result;
16460
16461   arg1 = (Dali::BaseHandle *)jarg1;
16462   arg2 = (Dali::BaseHandle *)jarg2;
16463   if (!arg2) {
16464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16465     return 0;
16466   }
16467   {
16468     try {
16469       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
16470     } catch (std::out_of_range& e) {
16471       {
16472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16473       };
16474     } catch (std::exception& e) {
16475       {
16476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16477       };
16478     } catch (...) {
16479       {
16480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16481       };
16482     }
16483   }
16484   jresult = result;
16485   return jresult;
16486 }
16487
16488
16489 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
16490   unsigned int jresult ;
16491   Dali::BaseHandle *arg1 = 0 ;
16492   Dali::BaseHandle *arg2 = 0 ;
16493   bool result;
16494
16495   arg1 = (Dali::BaseHandle *)jarg1;
16496   if (!arg1) {
16497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16498     return 0;
16499   }
16500   arg2 = (Dali::BaseHandle *)jarg2;
16501   if (!arg2) {
16502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16503     return 0;
16504   }
16505   {
16506     try {
16507       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
16508     } catch (std::out_of_range& e) {
16509       {
16510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16511       };
16512     } catch (std::exception& e) {
16513       {
16514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16515       };
16516     } catch (...) {
16517       {
16518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16519       };
16520     }
16521   }
16522   jresult = result;
16523   return jresult;
16524 }
16525
16526
16527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
16528   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16529
16530   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16531   {
16532     try {
16533       delete arg1;
16534     } catch (std::out_of_range& e) {
16535       {
16536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16537       };
16538     } catch (std::exception& e) {
16539       {
16540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16541       };
16542     } catch (...) {
16543       {
16544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16545       };
16546     }
16547   }
16548 }
16549
16550
16551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16552   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16553   SlotObserver *arg2 = (SlotObserver *) 0 ;
16554   CallbackBase *arg3 = (CallbackBase *) 0 ;
16555
16556   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16557   arg2 = (SlotObserver *)jarg2;
16558   arg3 = (CallbackBase *)jarg3;
16559   {
16560     try {
16561       (arg1)->SignalConnected(arg2,arg3);
16562     } catch (std::out_of_range& e) {
16563       {
16564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16565       };
16566     } catch (std::exception& e) {
16567       {
16568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16569       };
16570     } catch (...) {
16571       {
16572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16573       };
16574     }
16575   }
16576 }
16577
16578
16579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
16580   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16581
16582   arg1 = (Dali::SignalObserver *)jarg1;
16583   {
16584     try {
16585       delete arg1;
16586     } catch (std::out_of_range& e) {
16587       {
16588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16589       };
16590     } catch (std::exception& e) {
16591       {
16592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16593       };
16594     } catch (...) {
16595       {
16596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16597       };
16598     }
16599   }
16600 }
16601
16602
16603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16604   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16605   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16606   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16607
16608   arg1 = (Dali::SignalObserver *)jarg1;
16609   arg2 = (Dali::SlotObserver *)jarg2;
16610   arg3 = (Dali::CallbackBase *)jarg3;
16611   {
16612     try {
16613       (arg1)->SignalDisconnected(arg2,arg3);
16614     } catch (std::out_of_range& e) {
16615       {
16616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16617       };
16618     } catch (std::exception& e) {
16619       {
16620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16621       };
16622     } catch (...) {
16623       {
16624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16625       };
16626     }
16627   }
16628 }
16629
16630
16631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
16632   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16633
16634   arg1 = (Dali::SlotObserver *)jarg1;
16635   {
16636     try {
16637       delete arg1;
16638     } catch (std::out_of_range& e) {
16639       {
16640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16641       };
16642     } catch (std::exception& e) {
16643       {
16644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16645       };
16646     } catch (...) {
16647       {
16648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16649       };
16650     }
16651   }
16652 }
16653
16654
16655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
16656   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16657   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
16658
16659   arg1 = (Dali::SlotObserver *)jarg1;
16660   arg2 = (Dali::CallbackBase *)jarg2;
16661   {
16662     try {
16663       (arg1)->SlotDisconnected(arg2);
16664     } catch (std::out_of_range& e) {
16665       {
16666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16667       };
16668     } catch (std::exception& e) {
16669       {
16670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16671       };
16672     } catch (...) {
16673       {
16674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16675       };
16676     }
16677   }
16678 }
16679
16680
16681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
16682   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16683
16684   arg1 = (Dali::ConnectionTracker *)jarg1;
16685   {
16686     try {
16687       delete arg1;
16688     } catch (std::out_of_range& e) {
16689       {
16690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16691       };
16692     } catch (std::exception& e) {
16693       {
16694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16695       };
16696     } catch (...) {
16697       {
16698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16699       };
16700     }
16701   }
16702 }
16703
16704
16705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
16706   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16707
16708   arg1 = (Dali::ConnectionTracker *)jarg1;
16709   {
16710     try {
16711       (arg1)->DisconnectAll();
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_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16730   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16731   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16732   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16733
16734   arg1 = (Dali::ConnectionTracker *)jarg1;
16735   arg2 = (Dali::SlotObserver *)jarg2;
16736   arg3 = (Dali::CallbackBase *)jarg3;
16737   {
16738     try {
16739       (arg1)->SignalConnected(arg2,arg3);
16740     } catch (std::out_of_range& e) {
16741       {
16742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16743       };
16744     } catch (std::exception& e) {
16745       {
16746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16747       };
16748     } catch (...) {
16749       {
16750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16751       };
16752     }
16753   }
16754 }
16755
16756
16757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16758   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16759   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16760   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16761
16762   arg1 = (Dali::ConnectionTracker *)jarg1;
16763   arg2 = (Dali::SlotObserver *)jarg2;
16764   arg3 = (Dali::CallbackBase *)jarg3;
16765   {
16766     try {
16767       (arg1)->SignalDisconnected(arg2,arg3);
16768     } catch (std::out_of_range& e) {
16769       {
16770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16771       };
16772     } catch (std::exception& e) {
16773       {
16774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16775       };
16776     } catch (...) {
16777       {
16778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16779       };
16780     }
16781   }
16782 }
16783
16784
16785 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
16786   unsigned long jresult ;
16787   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16788   std::size_t result;
16789
16790   arg1 = (Dali::ConnectionTracker *)jarg1;
16791   {
16792     try {
16793       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
16794     } catch (std::out_of_range& e) {
16795       {
16796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16797       };
16798     } catch (std::exception& e) {
16799       {
16800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16801       };
16802     } catch (...) {
16803       {
16804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16805       };
16806     }
16807   }
16808   jresult = (unsigned long)result;
16809   return jresult;
16810 }
16811
16812
16813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
16814   void * jresult ;
16815   Dali::ObjectRegistry *result = 0 ;
16816
16817   {
16818     try {
16819       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
16820     } catch (std::out_of_range& e) {
16821       {
16822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16823       };
16824     } catch (std::exception& e) {
16825       {
16826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16827       };
16828     } catch (...) {
16829       {
16830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16831       };
16832     }
16833   }
16834   jresult = (void *)result;
16835   return jresult;
16836 }
16837
16838
16839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
16840   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16841
16842   arg1 = (Dali::ObjectRegistry *)jarg1;
16843   {
16844     try {
16845       delete arg1;
16846     } catch (std::out_of_range& e) {
16847       {
16848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16849       };
16850     } catch (std::exception& e) {
16851       {
16852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16853       };
16854     } catch (...) {
16855       {
16856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16857       };
16858     }
16859   }
16860 }
16861
16862
16863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
16864   void * jresult ;
16865   Dali::ObjectRegistry *arg1 = 0 ;
16866   Dali::ObjectRegistry *result = 0 ;
16867
16868   arg1 = (Dali::ObjectRegistry *)jarg1;
16869   if (!arg1) {
16870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16871     return 0;
16872   }
16873   {
16874     try {
16875       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
16876     } catch (std::out_of_range& e) {
16877       {
16878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16879       };
16880     } catch (std::exception& e) {
16881       {
16882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16883       };
16884     } catch (...) {
16885       {
16886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16887       };
16888     }
16889   }
16890   jresult = (void *)result;
16891   return jresult;
16892 }
16893
16894
16895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
16896   void * jresult ;
16897   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16898   Dali::ObjectRegistry *arg2 = 0 ;
16899   Dali::ObjectRegistry *result = 0 ;
16900
16901   arg1 = (Dali::ObjectRegistry *)jarg1;
16902   arg2 = (Dali::ObjectRegistry *)jarg2;
16903   if (!arg2) {
16904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16905     return 0;
16906   }
16907   {
16908     try {
16909       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
16910     } catch (std::out_of_range& e) {
16911       {
16912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16913       };
16914     } catch (std::exception& e) {
16915       {
16916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16917       };
16918     } catch (...) {
16919       {
16920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16921       };
16922     }
16923   }
16924   jresult = (void *)result;
16925   return jresult;
16926 }
16927
16928
16929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
16930   void * jresult ;
16931   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16932   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
16933
16934   arg1 = (Dali::ObjectRegistry *)jarg1;
16935   {
16936     try {
16937       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
16938     } catch (std::out_of_range& e) {
16939       {
16940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16941       };
16942     } catch (std::exception& e) {
16943       {
16944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16945       };
16946     } catch (...) {
16947       {
16948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16949       };
16950     }
16951   }
16952   jresult = (void *)result;
16953   return jresult;
16954 }
16955
16956
16957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
16958   void * jresult ;
16959   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16960   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
16961
16962   arg1 = (Dali::ObjectRegistry *)jarg1;
16963   {
16964     try {
16965       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
16966     } catch (std::out_of_range& e) {
16967       {
16968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16969       };
16970     } catch (std::exception& e) {
16971       {
16972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16973       };
16974     } catch (...) {
16975       {
16976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16977       };
16978     }
16979   }
16980   jresult = (void *)result;
16981   return jresult;
16982 }
16983
16984
16985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
16986   void * jresult ;
16987   Dali::PropertyCondition *result = 0 ;
16988
16989   {
16990     try {
16991       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
16992     } catch (std::out_of_range& e) {
16993       {
16994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16995       };
16996     } catch (std::exception& e) {
16997       {
16998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16999       };
17000     } catch (...) {
17001       {
17002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17003       };
17004     }
17005   }
17006   jresult = (void *)result;
17007   return jresult;
17008 }
17009
17010
17011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
17012   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17013
17014   arg1 = (Dali::PropertyCondition *)jarg1;
17015   {
17016     try {
17017       delete arg1;
17018     } catch (std::out_of_range& e) {
17019       {
17020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17021       };
17022     } catch (std::exception& e) {
17023       {
17024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17025       };
17026     } catch (...) {
17027       {
17028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17029       };
17030     }
17031   }
17032 }
17033
17034
17035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
17036   void * jresult ;
17037   Dali::PropertyCondition *arg1 = 0 ;
17038   Dali::PropertyCondition *result = 0 ;
17039
17040   arg1 = (Dali::PropertyCondition *)jarg1;
17041   if (!arg1) {
17042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17043     return 0;
17044   }
17045   {
17046     try {
17047       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
17048     } catch (std::out_of_range& e) {
17049       {
17050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17051       };
17052     } catch (std::exception& e) {
17053       {
17054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17055       };
17056     } catch (...) {
17057       {
17058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17059       };
17060     }
17061   }
17062   jresult = (void *)result;
17063   return jresult;
17064 }
17065
17066
17067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
17068   void * jresult ;
17069   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17070   Dali::PropertyCondition *arg2 = 0 ;
17071   Dali::PropertyCondition *result = 0 ;
17072
17073   arg1 = (Dali::PropertyCondition *)jarg1;
17074   arg2 = (Dali::PropertyCondition *)jarg2;
17075   if (!arg2) {
17076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17077     return 0;
17078   }
17079   {
17080     try {
17081       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
17082     } catch (std::out_of_range& e) {
17083       {
17084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17085       };
17086     } catch (std::exception& e) {
17087       {
17088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17089       };
17090     } catch (...) {
17091       {
17092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17093       };
17094     }
17095   }
17096   jresult = (void *)result;
17097   return jresult;
17098 }
17099
17100
17101 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
17102   unsigned long jresult ;
17103   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17104   std::size_t result;
17105
17106   arg1 = (Dali::PropertyCondition *)jarg1;
17107   {
17108     try {
17109       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
17110     } catch (std::out_of_range& e) {
17111       {
17112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17113       };
17114     } catch (std::exception& e) {
17115       {
17116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17117       };
17118     } catch (...) {
17119       {
17120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17121       };
17122     }
17123   }
17124   jresult = (unsigned long)result;
17125   return jresult;
17126 }
17127
17128
17129 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
17130   float jresult ;
17131   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17132   std::size_t arg2 ;
17133   float result;
17134
17135   arg1 = (Dali::PropertyCondition *)jarg1;
17136   arg2 = (std::size_t)jarg2;
17137   {
17138     try {
17139       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
17140     } catch (std::out_of_range& e) {
17141       {
17142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17143       };
17144     } catch (std::exception& e) {
17145       {
17146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17147       };
17148     } catch (...) {
17149       {
17150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17151       };
17152     }
17153   }
17154   jresult = result;
17155   return jresult;
17156 }
17157
17158
17159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
17160   void * jresult ;
17161   float arg1 ;
17162   Dali::PropertyCondition result;
17163
17164   arg1 = (float)jarg1;
17165   {
17166     try {
17167       result = Dali::LessThanCondition(arg1);
17168     } catch (std::out_of_range& e) {
17169       {
17170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17171       };
17172     } catch (std::exception& e) {
17173       {
17174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17175       };
17176     } catch (...) {
17177       {
17178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17179       };
17180     }
17181   }
17182   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17183   return jresult;
17184 }
17185
17186
17187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
17188   void * jresult ;
17189   float arg1 ;
17190   Dali::PropertyCondition result;
17191
17192   arg1 = (float)jarg1;
17193   {
17194     try {
17195       result = Dali::GreaterThanCondition(arg1);
17196     } catch (std::out_of_range& e) {
17197       {
17198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17199       };
17200     } catch (std::exception& e) {
17201       {
17202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17203       };
17204     } catch (...) {
17205       {
17206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17207       };
17208     }
17209   }
17210   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17211   return jresult;
17212 }
17213
17214
17215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
17216   void * jresult ;
17217   float arg1 ;
17218   float arg2 ;
17219   Dali::PropertyCondition result;
17220
17221   arg1 = (float)jarg1;
17222   arg2 = (float)jarg2;
17223   {
17224     try {
17225       result = Dali::InsideCondition(arg1,arg2);
17226     } catch (std::out_of_range& e) {
17227       {
17228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17229       };
17230     } catch (std::exception& e) {
17231       {
17232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17233       };
17234     } catch (...) {
17235       {
17236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17237       };
17238     }
17239   }
17240   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17241   return jresult;
17242 }
17243
17244
17245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
17246   void * jresult ;
17247   float arg1 ;
17248   float arg2 ;
17249   Dali::PropertyCondition result;
17250
17251   arg1 = (float)jarg1;
17252   arg2 = (float)jarg2;
17253   {
17254     try {
17255       result = Dali::OutsideCondition(arg1,arg2);
17256     } catch (std::out_of_range& e) {
17257       {
17258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17259       };
17260     } catch (std::exception& e) {
17261       {
17262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17263       };
17264     } catch (...) {
17265       {
17266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17267       };
17268     }
17269   }
17270   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17271   return jresult;
17272 }
17273
17274
17275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
17276   void * jresult ;
17277   float arg1 ;
17278   float arg2 ;
17279   Dali::PropertyCondition result;
17280
17281   arg1 = (float)jarg1;
17282   arg2 = (float)jarg2;
17283   {
17284     try {
17285       result = Dali::StepCondition(arg1,arg2);
17286     } catch (std::out_of_range& e) {
17287       {
17288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17289       };
17290     } catch (std::exception& e) {
17291       {
17292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17293       };
17294     } catch (...) {
17295       {
17296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17297       };
17298     }
17299   }
17300   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17301   return jresult;
17302 }
17303
17304
17305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
17306   void * jresult ;
17307   float arg1 ;
17308   Dali::PropertyCondition result;
17309
17310   arg1 = (float)jarg1;
17311   {
17312     try {
17313       result = Dali::StepCondition(arg1);
17314     } catch (std::out_of_range& e) {
17315       {
17316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17317       };
17318     } catch (std::exception& e) {
17319       {
17320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17321       };
17322     } catch (...) {
17323       {
17324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17325       };
17326     }
17327   }
17328   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17329   return jresult;
17330 }
17331
17332
17333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
17334   void * jresult ;
17335   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
17336   Dali::PropertyCondition result;
17337
17338   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
17339   if (!arg1) {
17340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
17341     return 0;
17342   }
17343   {
17344     try {
17345       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
17346     } catch (std::out_of_range& e) {
17347       {
17348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17349       };
17350     } catch (std::exception& e) {
17351       {
17352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17353       };
17354     } catch (...) {
17355       {
17356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17357       };
17358     }
17359   }
17360   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17361   return jresult;
17362 }
17363
17364
17365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
17366   void * jresult ;
17367   Dali::PropertyNotification *result = 0 ;
17368
17369   {
17370     try {
17371       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
17372     } catch (std::out_of_range& e) {
17373       {
17374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17375       };
17376     } catch (std::exception& e) {
17377       {
17378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17379       };
17380     } catch (...) {
17381       {
17382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17383       };
17384     }
17385   }
17386   jresult = (void *)result;
17387   return jresult;
17388 }
17389
17390
17391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
17392   void * jresult ;
17393   Dali::BaseHandle arg1 ;
17394   Dali::BaseHandle *argp1 ;
17395   Dali::PropertyNotification result;
17396
17397   argp1 = (Dali::BaseHandle *)jarg1;
17398   if (!argp1) {
17399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17400     return 0;
17401   }
17402   arg1 = *argp1;
17403   {
17404     try {
17405       result = Dali::PropertyNotification::DownCast(arg1);
17406     } catch (std::out_of_range& e) {
17407       {
17408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17409       };
17410     } catch (std::exception& e) {
17411       {
17412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17413       };
17414     } catch (...) {
17415       {
17416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17417       };
17418     }
17419   }
17420   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
17421   return jresult;
17422 }
17423
17424
17425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
17426   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17427
17428   arg1 = (Dali::PropertyNotification *)jarg1;
17429   {
17430     try {
17431       delete arg1;
17432     } catch (std::out_of_range& e) {
17433       {
17434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17435       };
17436     } catch (std::exception& e) {
17437       {
17438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17439       };
17440     } catch (...) {
17441       {
17442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17443       };
17444     }
17445   }
17446 }
17447
17448
17449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
17450   void * jresult ;
17451   Dali::PropertyNotification *arg1 = 0 ;
17452   Dali::PropertyNotification *result = 0 ;
17453
17454   arg1 = (Dali::PropertyNotification *)jarg1;
17455   if (!arg1) {
17456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17457     return 0;
17458   }
17459   {
17460     try {
17461       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
17462     } catch (std::out_of_range& e) {
17463       {
17464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17465       };
17466     } catch (std::exception& e) {
17467       {
17468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17469       };
17470     } catch (...) {
17471       {
17472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17473       };
17474     }
17475   }
17476   jresult = (void *)result;
17477   return jresult;
17478 }
17479
17480
17481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
17482   void * jresult ;
17483   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17484   Dali::PropertyNotification *arg2 = 0 ;
17485   Dali::PropertyNotification *result = 0 ;
17486
17487   arg1 = (Dali::PropertyNotification *)jarg1;
17488   arg2 = (Dali::PropertyNotification *)jarg2;
17489   if (!arg2) {
17490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17491     return 0;
17492   }
17493   {
17494     try {
17495       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
17496     } catch (std::out_of_range& e) {
17497       {
17498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17499       };
17500     } catch (std::exception& e) {
17501       {
17502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17503       };
17504     } catch (...) {
17505       {
17506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17507       };
17508     }
17509   }
17510   jresult = (void *)result;
17511   return jresult;
17512 }
17513
17514
17515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
17516   void * jresult ;
17517   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17518   Dali::PropertyCondition result;
17519
17520   arg1 = (Dali::PropertyNotification *)jarg1;
17521   {
17522     try {
17523       result = (arg1)->GetCondition();
17524     } catch (std::out_of_range& e) {
17525       {
17526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17527       };
17528     } catch (std::exception& e) {
17529       {
17530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17531       };
17532     } catch (...) {
17533       {
17534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17535       };
17536     }
17537   }
17538   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17539   return jresult;
17540 }
17541
17542
17543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
17544   void * jresult ;
17545   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17546   Dali::Handle result;
17547
17548   arg1 = (Dali::PropertyNotification *)jarg1;
17549   {
17550     try {
17551       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
17552     } catch (std::out_of_range& e) {
17553       {
17554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17555       };
17556     } catch (std::exception& e) {
17557       {
17558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17559       };
17560     } catch (...) {
17561       {
17562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17563       };
17564     }
17565   }
17566   jresult = new Dali::Handle((const Dali::Handle &)result);
17567   return jresult;
17568 }
17569
17570
17571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
17572   int jresult ;
17573   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17574   Dali::Property::Index result;
17575
17576   arg1 = (Dali::PropertyNotification *)jarg1;
17577   {
17578     try {
17579       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
17580     } catch (std::out_of_range& e) {
17581       {
17582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17583       };
17584     } catch (std::exception& e) {
17585       {
17586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17587       };
17588     } catch (...) {
17589       {
17590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17591       };
17592     }
17593   }
17594   jresult = result;
17595   return jresult;
17596 }
17597
17598
17599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
17600   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17601   Dali::PropertyNotification::NotifyMode arg2 ;
17602
17603   arg1 = (Dali::PropertyNotification *)jarg1;
17604   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
17605   {
17606     try {
17607       (arg1)->SetNotifyMode(arg2);
17608     } catch (std::out_of_range& e) {
17609       {
17610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17611       };
17612     } catch (std::exception& e) {
17613       {
17614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17615       };
17616     } catch (...) {
17617       {
17618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17619       };
17620     }
17621   }
17622 }
17623
17624
17625 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
17626   int jresult ;
17627   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17628   Dali::PropertyNotification::NotifyMode result;
17629
17630   arg1 = (Dali::PropertyNotification *)jarg1;
17631   {
17632     try {
17633       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
17634     } catch (std::out_of_range& e) {
17635       {
17636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17637       };
17638     } catch (std::exception& e) {
17639       {
17640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17641       };
17642     } catch (...) {
17643       {
17644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17645       };
17646     }
17647   }
17648   jresult = (int)result;
17649   return jresult;
17650 }
17651
17652
17653 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
17654   unsigned int jresult ;
17655   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17656   bool result;
17657
17658   arg1 = (Dali::PropertyNotification *)jarg1;
17659   {
17660     try {
17661       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
17662     } catch (std::out_of_range& e) {
17663       {
17664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17665       };
17666     } catch (std::exception& e) {
17667       {
17668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17669       };
17670     } catch (...) {
17671       {
17672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17673       };
17674     }
17675   }
17676   jresult = result;
17677   return jresult;
17678 }
17679
17680
17681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
17682   void * jresult ;
17683   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17684   Dali::PropertyNotifySignalType *result = 0 ;
17685
17686   arg1 = (Dali::PropertyNotification *)jarg1;
17687   {
17688     try {
17689       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
17690     } catch (std::out_of_range& e) {
17691       {
17692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17693       };
17694     } catch (std::exception& e) {
17695       {
17696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17697       };
17698     } catch (...) {
17699       {
17700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17701       };
17702     }
17703   }
17704   jresult = (void *)result;
17705   return jresult;
17706 }
17707
17708
17709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
17710   void * jresult ;
17711   Dali::Handle *result = 0 ;
17712
17713   {
17714     try {
17715       result = (Dali::Handle *)new Dali::Handle();
17716     } catch (std::out_of_range& e) {
17717       {
17718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17719       };
17720     } catch (std::exception& e) {
17721       {
17722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17723       };
17724     } catch (...) {
17725       {
17726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17727       };
17728     }
17729   }
17730   jresult = (void *)result;
17731   return jresult;
17732 }
17733
17734
17735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
17736   void * jresult ;
17737   Dali::Handle result;
17738
17739   {
17740     try {
17741       result = Dali::Handle::New();
17742     } catch (std::out_of_range& e) {
17743       {
17744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17745       };
17746     } catch (std::exception& e) {
17747       {
17748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17749       };
17750     } catch (...) {
17751       {
17752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17753       };
17754     }
17755   }
17756   jresult = new Dali::Handle((const Dali::Handle &)result);
17757   return jresult;
17758 }
17759
17760
17761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
17762   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17763
17764   arg1 = (Dali::Handle *)jarg1;
17765   {
17766     try {
17767       delete arg1;
17768     } catch (std::out_of_range& e) {
17769       {
17770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17771       };
17772     } catch (std::exception& e) {
17773       {
17774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17775       };
17776     } catch (...) {
17777       {
17778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17779       };
17780     }
17781   }
17782 }
17783
17784
17785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
17786   void * jresult ;
17787   Dali::Handle *arg1 = 0 ;
17788   Dali::Handle *result = 0 ;
17789
17790   arg1 = (Dali::Handle *)jarg1;
17791   if (!arg1) {
17792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17793     return 0;
17794   }
17795   {
17796     try {
17797       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
17798     } catch (std::out_of_range& e) {
17799       {
17800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17801       };
17802     } catch (std::exception& e) {
17803       {
17804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17805       };
17806     } catch (...) {
17807       {
17808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17809       };
17810     }
17811   }
17812   jresult = (void *)result;
17813   return jresult;
17814 }
17815
17816
17817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
17818   void * jresult ;
17819   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17820   Dali::Handle *arg2 = 0 ;
17821   Dali::Handle *result = 0 ;
17822
17823   arg1 = (Dali::Handle *)jarg1;
17824   arg2 = (Dali::Handle *)jarg2;
17825   if (!arg2) {
17826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17827     return 0;
17828   }
17829   {
17830     try {
17831       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
17832     } catch (std::out_of_range& e) {
17833       {
17834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17835       };
17836     } catch (std::exception& e) {
17837       {
17838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17839       };
17840     } catch (...) {
17841       {
17842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17843       };
17844     }
17845   }
17846   jresult = (void *)result;
17847   return jresult;
17848 }
17849
17850
17851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
17852   void * jresult ;
17853   Dali::BaseHandle arg1 ;
17854   Dali::BaseHandle *argp1 ;
17855   Dali::Handle result;
17856
17857   argp1 = (Dali::BaseHandle *)jarg1;
17858   if (!argp1) {
17859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17860     return 0;
17861   }
17862   arg1 = *argp1;
17863   {
17864     try {
17865       result = Dali::Handle::DownCast(arg1);
17866     } catch (std::out_of_range& e) {
17867       {
17868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17869       };
17870     } catch (std::exception& e) {
17871       {
17872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17873       };
17874     } catch (...) {
17875       {
17876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17877       };
17878     }
17879   }
17880   jresult = new Dali::Handle((const Dali::Handle &)result);
17881   return jresult;
17882 }
17883
17884
17885 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
17886   unsigned int jresult ;
17887   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17888   Dali::Handle::Capability arg2 ;
17889   bool result;
17890
17891   arg1 = (Dali::Handle *)jarg1;
17892   arg2 = (Dali::Handle::Capability)jarg2;
17893   {
17894     try {
17895       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
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 = result;
17911   return jresult;
17912 }
17913
17914
17915 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
17916   unsigned int jresult ;
17917   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17918   unsigned int result;
17919
17920   arg1 = (Dali::Handle *)jarg1;
17921   {
17922     try {
17923       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
17924     } catch (std::out_of_range& e) {
17925       {
17926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17927       };
17928     } catch (std::exception& e) {
17929       {
17930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17931       };
17932     } catch (...) {
17933       {
17934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17935       };
17936     }
17937   }
17938   jresult = result;
17939   return jresult;
17940 }
17941
17942
17943 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
17944   char * jresult ;
17945   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17946   Dali::Property::Index arg2 ;
17947   std::string result;
17948
17949   arg1 = (Dali::Handle *)jarg1;
17950   arg2 = (Dali::Property::Index)jarg2;
17951   {
17952     try {
17953       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
17954     } catch (std::out_of_range& e) {
17955       {
17956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17957       };
17958     } catch (std::exception& e) {
17959       {
17960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17961       };
17962     } catch (...) {
17963       {
17964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17965       };
17966     }
17967   }
17968   jresult = SWIG_csharp_string_callback((&result)->c_str());
17969   return jresult;
17970 }
17971
17972
17973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
17974   int jresult ;
17975   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17976   std::string *arg2 = 0 ;
17977   Dali::Property::Index result;
17978
17979   arg1 = (Dali::Handle *)jarg1;
17980   if (!jarg2) {
17981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17982     return 0;
17983   }
17984   std::string arg2_str(jarg2);
17985   arg2 = &arg2_str;
17986   {
17987     try {
17988       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
17989     } catch (std::out_of_range& e) {
17990       {
17991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17992       };
17993     } catch (std::exception& e) {
17994       {
17995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17996       };
17997     } catch (...) {
17998       {
17999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18000       };
18001     }
18002   }
18003   jresult = result;
18004
18005   //argout typemap for const std::string&
18006
18007   return jresult;
18008 }
18009
18010
18011 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
18012   unsigned int jresult ;
18013   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18014   Dali::Property::Index arg2 ;
18015   bool result;
18016
18017   arg1 = (Dali::Handle *)jarg1;
18018   arg2 = (Dali::Property::Index)jarg2;
18019   {
18020     try {
18021       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
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 unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
18042   unsigned int jresult ;
18043   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18044   Dali::Property::Index arg2 ;
18045   bool result;
18046
18047   arg1 = (Dali::Handle *)jarg1;
18048   arg2 = (Dali::Property::Index)jarg2;
18049   {
18050     try {
18051       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
18052     } catch (std::out_of_range& e) {
18053       {
18054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18055       };
18056     } catch (std::exception& e) {
18057       {
18058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18059       };
18060     } catch (...) {
18061       {
18062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18063       };
18064     }
18065   }
18066   jresult = result;
18067   return jresult;
18068 }
18069
18070
18071 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
18072   unsigned int jresult ;
18073   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18074   Dali::Property::Index arg2 ;
18075   bool result;
18076
18077   arg1 = (Dali::Handle *)jarg1;
18078   arg2 = (Dali::Property::Index)jarg2;
18079   {
18080     try {
18081       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
18082     } catch (std::out_of_range& e) {
18083       {
18084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18085       };
18086     } catch (std::exception& e) {
18087       {
18088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18089       };
18090     } catch (...) {
18091       {
18092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18093       };
18094     }
18095   }
18096   jresult = result;
18097   return jresult;
18098 }
18099
18100
18101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
18102   int jresult ;
18103   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18104   Dali::Property::Index arg2 ;
18105   Dali::Property::Type result;
18106
18107   arg1 = (Dali::Handle *)jarg1;
18108   arg2 = (Dali::Property::Index)jarg2;
18109   {
18110     try {
18111       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
18112     } catch (std::out_of_range& e) {
18113       {
18114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18115       };
18116     } catch (std::exception& e) {
18117       {
18118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18119       };
18120     } catch (...) {
18121       {
18122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18123       };
18124     }
18125   }
18126   jresult = (int)result;
18127   return jresult;
18128 }
18129
18130
18131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
18132   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18133   Dali::Property::Index arg2 ;
18134   Dali::Property::Value *arg3 = 0 ;
18135
18136   arg1 = (Dali::Handle *)jarg1;
18137   arg2 = (Dali::Property::Index)jarg2;
18138   arg3 = (Dali::Property::Value *)jarg3;
18139   if (!arg3) {
18140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18141     return ;
18142   }
18143   {
18144     try {
18145       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
18146     } catch (std::out_of_range& e) {
18147       {
18148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18149       };
18150     } catch (std::exception& e) {
18151       {
18152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18153       };
18154     } catch (...) {
18155       {
18156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18157       };
18158     }
18159   }
18160 }
18161
18162
18163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
18164   int jresult ;
18165   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18166   std::string *arg2 = 0 ;
18167   Dali::Property::Value *arg3 = 0 ;
18168   Dali::Property::Index result;
18169
18170   arg1 = (Dali::Handle *)jarg1;
18171   if (!jarg2) {
18172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18173     return 0;
18174   }
18175   std::string arg2_str(jarg2);
18176   arg2 = &arg2_str;
18177   arg3 = (Dali::Property::Value *)jarg3;
18178   if (!arg3) {
18179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18180     return 0;
18181   }
18182   {
18183     try {
18184       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
18185     } catch (std::out_of_range& e) {
18186       {
18187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18188       };
18189     } catch (std::exception& e) {
18190       {
18191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18192       };
18193     } catch (...) {
18194       {
18195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18196       };
18197     }
18198   }
18199   jresult = result;
18200
18201   //argout typemap for const std::string&
18202
18203   return jresult;
18204 }
18205
18206
18207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
18208   int jresult ;
18209   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18210   std::string *arg2 = 0 ;
18211   Dali::Property::Value *arg3 = 0 ;
18212   Dali::Property::AccessMode arg4 ;
18213   Dali::Property::Index result;
18214
18215   arg1 = (Dali::Handle *)jarg1;
18216   if (!jarg2) {
18217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18218     return 0;
18219   }
18220   std::string arg2_str(jarg2);
18221   arg2 = &arg2_str;
18222   arg3 = (Dali::Property::Value *)jarg3;
18223   if (!arg3) {
18224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18225     return 0;
18226   }
18227   arg4 = (Dali::Property::AccessMode)jarg4;
18228   {
18229     try {
18230       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
18231     } catch (std::out_of_range& e) {
18232       {
18233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18234       };
18235     } catch (std::exception& e) {
18236       {
18237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18238       };
18239     } catch (...) {
18240       {
18241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18242       };
18243     }
18244   }
18245   jresult = result;
18246
18247   //argout typemap for const std::string&
18248
18249   return jresult;
18250 }
18251
18252
18253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
18254   void * jresult ;
18255   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18256   Dali::Property::Index arg2 ;
18257   Dali::Property::Value result;
18258
18259   arg1 = (Dali::Handle *)jarg1;
18260   arg2 = (Dali::Property::Index)jarg2;
18261   {
18262     try {
18263       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
18264     } catch (std::out_of_range& e) {
18265       {
18266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18267       };
18268     } catch (std::exception& e) {
18269       {
18270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18271       };
18272     } catch (...) {
18273       {
18274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18275       };
18276     }
18277   }
18278   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
18279   return jresult;
18280 }
18281
18282
18283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
18284   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18285   Dali::Property::IndexContainer *arg2 = 0 ;
18286
18287   arg1 = (Dali::Handle *)jarg1;
18288   arg2 = (Dali::Property::IndexContainer *)jarg2;
18289   if (!arg2) {
18290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18291     return ;
18292   }
18293   {
18294     try {
18295       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
18296     } catch (std::out_of_range& e) {
18297       {
18298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18299       };
18300     } catch (std::exception& e) {
18301       {
18302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18303       };
18304     } catch (...) {
18305       {
18306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18307       };
18308     }
18309   }
18310 }
18311
18312
18313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
18314   void * jresult ;
18315   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18316   Dali::Property::Index arg2 ;
18317   Dali::PropertyCondition *arg3 = 0 ;
18318   Dali::PropertyNotification result;
18319
18320   arg1 = (Dali::Handle *)jarg1;
18321   arg2 = (Dali::Property::Index)jarg2;
18322   arg3 = (Dali::PropertyCondition *)jarg3;
18323   if (!arg3) {
18324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18325     return 0;
18326   }
18327   {
18328     try {
18329       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
18330     } catch (std::out_of_range& e) {
18331       {
18332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18333       };
18334     } catch (std::exception& e) {
18335       {
18336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18337       };
18338     } catch (...) {
18339       {
18340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18341       };
18342     }
18343   }
18344   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18345   return jresult;
18346 }
18347
18348
18349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
18350   void * jresult ;
18351   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18352   Dali::Property::Index arg2 ;
18353   int arg3 ;
18354   Dali::PropertyCondition *arg4 = 0 ;
18355   Dali::PropertyNotification result;
18356
18357   arg1 = (Dali::Handle *)jarg1;
18358   arg2 = (Dali::Property::Index)jarg2;
18359   arg3 = (int)jarg3;
18360   arg4 = (Dali::PropertyCondition *)jarg4;
18361   if (!arg4) {
18362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18363     return 0;
18364   }
18365   {
18366     try {
18367       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
18368     } catch (std::out_of_range& e) {
18369       {
18370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18371       };
18372     } catch (std::exception& e) {
18373       {
18374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18375       };
18376     } catch (...) {
18377       {
18378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18379       };
18380     }
18381   }
18382   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18383   return jresult;
18384 }
18385
18386
18387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
18388   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18389   Dali::PropertyNotification arg2 ;
18390   Dali::PropertyNotification *argp2 ;
18391
18392   arg1 = (Dali::Handle *)jarg1;
18393   argp2 = (Dali::PropertyNotification *)jarg2;
18394   if (!argp2) {
18395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
18396     return ;
18397   }
18398   arg2 = *argp2;
18399   {
18400     try {
18401       (arg1)->RemovePropertyNotification(arg2);
18402     } catch (std::out_of_range& e) {
18403       {
18404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18405       };
18406     } catch (std::exception& e) {
18407       {
18408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18409       };
18410     } catch (...) {
18411       {
18412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18413       };
18414     }
18415   }
18416 }
18417
18418
18419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
18420   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18421
18422   arg1 = (Dali::Handle *)jarg1;
18423   {
18424     try {
18425       (arg1)->RemovePropertyNotifications();
18426     } catch (std::out_of_range& e) {
18427       {
18428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18429       };
18430     } catch (std::exception& e) {
18431       {
18432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18433       };
18434     } catch (...) {
18435       {
18436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18437       };
18438     }
18439   }
18440 }
18441
18442
18443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
18444   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18445
18446   arg1 = (Dali::Handle *)jarg1;
18447   {
18448     try {
18449       (arg1)->RemoveConstraints();
18450     } catch (std::out_of_range& e) {
18451       {
18452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18453       };
18454     } catch (std::exception& e) {
18455       {
18456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18457       };
18458     } catch (...) {
18459       {
18460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18461       };
18462     }
18463   }
18464 }
18465
18466
18467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
18468   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18469   unsigned int arg2 ;
18470
18471   arg1 = (Dali::Handle *)jarg1;
18472   arg2 = (unsigned int)jarg2;
18473   {
18474     try {
18475       (arg1)->RemoveConstraints(arg2);
18476     } catch (std::out_of_range& e) {
18477       {
18478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18479       };
18480     } catch (std::exception& e) {
18481       {
18482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18483       };
18484     } catch (...) {
18485       {
18486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18487       };
18488     }
18489   }
18490 }
18491
18492
18493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
18494   int jresult ;
18495   Dali::Property::Index result;
18496
18497   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
18498   jresult = result;
18499   return jresult;
18500 }
18501
18502
18503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
18504   void * jresult ;
18505   Dali::Handle result;
18506
18507   {
18508     try {
18509       result = Dali::WeightObject::New();
18510     } catch (std::out_of_range& e) {
18511       {
18512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18513       };
18514     } catch (std::exception& e) {
18515       {
18516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18517       };
18518     } catch (...) {
18519       {
18520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18521       };
18522     }
18523   }
18524   jresult = new Dali::Handle((const Dali::Handle &)result);
18525   return jresult;
18526 }
18527
18528
18529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
18530   void * jresult ;
18531   Dali::TypeInfo *result = 0 ;
18532
18533   {
18534     try {
18535       result = (Dali::TypeInfo *)new Dali::TypeInfo();
18536     } catch (std::out_of_range& e) {
18537       {
18538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18539       };
18540     } catch (std::exception& e) {
18541       {
18542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18543       };
18544     } catch (...) {
18545       {
18546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18547       };
18548     }
18549   }
18550   jresult = (void *)result;
18551   return jresult;
18552 }
18553
18554
18555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
18556   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18557
18558   arg1 = (Dali::TypeInfo *)jarg1;
18559   {
18560     try {
18561       delete arg1;
18562     } catch (std::out_of_range& e) {
18563       {
18564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18565       };
18566     } catch (std::exception& e) {
18567       {
18568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18569       };
18570     } catch (...) {
18571       {
18572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18573       };
18574     }
18575   }
18576 }
18577
18578
18579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
18580   void * jresult ;
18581   Dali::TypeInfo *arg1 = 0 ;
18582   Dali::TypeInfo *result = 0 ;
18583
18584   arg1 = (Dali::TypeInfo *)jarg1;
18585   if (!arg1) {
18586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18587     return 0;
18588   }
18589   {
18590     try {
18591       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
18592     } catch (std::out_of_range& e) {
18593       {
18594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18595       };
18596     } catch (std::exception& e) {
18597       {
18598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18599       };
18600     } catch (...) {
18601       {
18602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18603       };
18604     }
18605   }
18606   jresult = (void *)result;
18607   return jresult;
18608 }
18609
18610
18611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
18612   void * jresult ;
18613   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18614   Dali::TypeInfo *arg2 = 0 ;
18615   Dali::TypeInfo *result = 0 ;
18616
18617   arg1 = (Dali::TypeInfo *)jarg1;
18618   arg2 = (Dali::TypeInfo *)jarg2;
18619   if (!arg2) {
18620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18621     return 0;
18622   }
18623   {
18624     try {
18625       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
18626     } catch (std::out_of_range& e) {
18627       {
18628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18629       };
18630     } catch (std::exception& e) {
18631       {
18632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18633       };
18634     } catch (...) {
18635       {
18636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18637       };
18638     }
18639   }
18640   jresult = (void *)result;
18641   return jresult;
18642 }
18643
18644
18645 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
18646   char * jresult ;
18647   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18648   std::string *result = 0 ;
18649
18650   arg1 = (Dali::TypeInfo *)jarg1;
18651   {
18652     try {
18653       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
18654     } catch (std::out_of_range& e) {
18655       {
18656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18657       };
18658     } catch (std::exception& e) {
18659       {
18660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18661       };
18662     } catch (...) {
18663       {
18664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18665       };
18666     }
18667   }
18668   jresult = SWIG_csharp_string_callback(result->c_str());
18669   return jresult;
18670 }
18671
18672
18673 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
18674   char * jresult ;
18675   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18676   std::string *result = 0 ;
18677
18678   arg1 = (Dali::TypeInfo *)jarg1;
18679   {
18680     try {
18681       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
18682     } catch (std::out_of_range& e) {
18683       {
18684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18685       };
18686     } catch (std::exception& e) {
18687       {
18688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18689       };
18690     } catch (...) {
18691       {
18692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18693       };
18694     }
18695   }
18696   jresult = SWIG_csharp_string_callback(result->c_str());
18697   return jresult;
18698 }
18699
18700
18701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
18702   void * jresult ;
18703   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18704   Dali::BaseHandle result;
18705
18706   arg1 = (Dali::TypeInfo *)jarg1;
18707   {
18708     try {
18709       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
18710     } catch (std::out_of_range& e) {
18711       {
18712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18713       };
18714     } catch (std::exception& e) {
18715       {
18716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18717       };
18718     } catch (...) {
18719       {
18720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18721       };
18722     }
18723   }
18724   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
18725   return jresult;
18726 }
18727
18728
18729 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
18730   unsigned long jresult ;
18731   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18732   size_t result;
18733
18734   arg1 = (Dali::TypeInfo *)jarg1;
18735   {
18736     try {
18737       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
18738     } catch (std::out_of_range& e) {
18739       {
18740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18741       };
18742     } catch (std::exception& e) {
18743       {
18744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18745       };
18746     } catch (...) {
18747       {
18748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18749       };
18750     }
18751   }
18752   jresult = (unsigned long)result;
18753   return jresult;
18754 }
18755
18756
18757 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
18758   char * jresult ;
18759   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18760   size_t arg2 ;
18761   std::string result;
18762
18763   arg1 = (Dali::TypeInfo *)jarg1;
18764   arg2 = (size_t)jarg2;
18765   {
18766     try {
18767       result = (arg1)->GetActionName(arg2);
18768     } catch (std::out_of_range& e) {
18769       {
18770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18771       };
18772     } catch (std::exception& e) {
18773       {
18774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18775       };
18776     } catch (...) {
18777       {
18778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18779       };
18780     }
18781   }
18782   jresult = SWIG_csharp_string_callback((&result)->c_str());
18783   return jresult;
18784 }
18785
18786
18787 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
18788   unsigned long jresult ;
18789   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18790   size_t result;
18791
18792   arg1 = (Dali::TypeInfo *)jarg1;
18793   {
18794     try {
18795       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
18796     } catch (std::out_of_range& e) {
18797       {
18798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18799       };
18800     } catch (std::exception& e) {
18801       {
18802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18803       };
18804     } catch (...) {
18805       {
18806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18807       };
18808     }
18809   }
18810   jresult = (unsigned long)result;
18811   return jresult;
18812 }
18813
18814
18815 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
18816   char * jresult ;
18817   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18818   size_t arg2 ;
18819   std::string result;
18820
18821   arg1 = (Dali::TypeInfo *)jarg1;
18822   arg2 = (size_t)jarg2;
18823   {
18824     try {
18825       result = (arg1)->GetSignalName(arg2);
18826     } catch (std::out_of_range& e) {
18827       {
18828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18829       };
18830     } catch (std::exception& e) {
18831       {
18832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18833       };
18834     } catch (...) {
18835       {
18836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18837       };
18838     }
18839   }
18840   jresult = SWIG_csharp_string_callback((&result)->c_str());
18841   return jresult;
18842 }
18843
18844
18845 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
18846   unsigned long jresult ;
18847   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18848   size_t result;
18849
18850   arg1 = (Dali::TypeInfo *)jarg1;
18851   {
18852     try {
18853       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
18854     } catch (std::out_of_range& e) {
18855       {
18856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18857       };
18858     } catch (std::exception& e) {
18859       {
18860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18861       };
18862     } catch (...) {
18863       {
18864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18865       };
18866     }
18867   }
18868   jresult = (unsigned long)result;
18869   return jresult;
18870 }
18871
18872
18873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
18874   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18875   Dali::Property::IndexContainer *arg2 = 0 ;
18876
18877   arg1 = (Dali::TypeInfo *)jarg1;
18878   arg2 = (Dali::Property::IndexContainer *)jarg2;
18879   if (!arg2) {
18880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18881     return ;
18882   }
18883   {
18884     try {
18885       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
18886     } catch (std::out_of_range& e) {
18887       {
18888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18889       };
18890     } catch (std::exception& e) {
18891       {
18892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18893       };
18894     } catch (...) {
18895       {
18896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18897       };
18898     }
18899   }
18900 }
18901
18902
18903 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
18904   char * jresult ;
18905   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18906   Dali::Property::Index arg2 ;
18907   std::string *result = 0 ;
18908
18909   arg1 = (Dali::TypeInfo *)jarg1;
18910   arg2 = (Dali::Property::Index)jarg2;
18911   {
18912     try {
18913       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
18914     } catch (std::out_of_range& e) {
18915       {
18916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18917       };
18918     } catch (std::exception& e) {
18919       {
18920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18921       };
18922     } catch (...) {
18923       {
18924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18925       };
18926     }
18927   }
18928   jresult = SWIG_csharp_string_callback(result->c_str());
18929   return jresult;
18930 }
18931
18932
18933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
18934   void * jresult ;
18935   Dali::TypeRegistry result;
18936
18937   {
18938     try {
18939       result = Dali::TypeRegistry::Get();
18940     } catch (std::out_of_range& e) {
18941       {
18942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18943       };
18944     } catch (std::exception& e) {
18945       {
18946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18947       };
18948     } catch (...) {
18949       {
18950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18951       };
18952     }
18953   }
18954   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
18955   return jresult;
18956 }
18957
18958
18959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
18960   void * jresult ;
18961   Dali::TypeRegistry *result = 0 ;
18962
18963   {
18964     try {
18965       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
18966     } catch (std::out_of_range& e) {
18967       {
18968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18969       };
18970     } catch (std::exception& e) {
18971       {
18972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18973       };
18974     } catch (...) {
18975       {
18976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18977       };
18978     }
18979   }
18980   jresult = (void *)result;
18981   return jresult;
18982 }
18983
18984
18985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
18986   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
18987
18988   arg1 = (Dali::TypeRegistry *)jarg1;
18989   {
18990     try {
18991       delete arg1;
18992     } catch (std::out_of_range& e) {
18993       {
18994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18995       };
18996     } catch (std::exception& e) {
18997       {
18998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18999       };
19000     } catch (...) {
19001       {
19002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19003       };
19004     }
19005   }
19006 }
19007
19008
19009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
19010   void * jresult ;
19011   Dali::TypeRegistry *arg1 = 0 ;
19012   Dali::TypeRegistry *result = 0 ;
19013
19014   arg1 = (Dali::TypeRegistry *)jarg1;
19015   if (!arg1) {
19016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19017     return 0;
19018   }
19019   {
19020     try {
19021       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
19022     } catch (std::out_of_range& e) {
19023       {
19024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19025       };
19026     } catch (std::exception& e) {
19027       {
19028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19029       };
19030     } catch (...) {
19031       {
19032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19033       };
19034     }
19035   }
19036   jresult = (void *)result;
19037   return jresult;
19038 }
19039
19040
19041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
19042   void * jresult ;
19043   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19044   Dali::TypeRegistry *arg2 = 0 ;
19045   Dali::TypeRegistry *result = 0 ;
19046
19047   arg1 = (Dali::TypeRegistry *)jarg1;
19048   arg2 = (Dali::TypeRegistry *)jarg2;
19049   if (!arg2) {
19050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19051     return 0;
19052   }
19053   {
19054     try {
19055       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
19056     } catch (std::out_of_range& e) {
19057       {
19058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19059       };
19060     } catch (std::exception& e) {
19061       {
19062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19063       };
19064     } catch (...) {
19065       {
19066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19067       };
19068     }
19069   }
19070   jresult = (void *)result;
19071   return jresult;
19072 }
19073
19074
19075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
19076   void * jresult ;
19077   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19078   std::string *arg2 = 0 ;
19079   Dali::TypeInfo result;
19080
19081   arg1 = (Dali::TypeRegistry *)jarg1;
19082   if (!jarg2) {
19083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19084     return 0;
19085   }
19086   std::string arg2_str(jarg2);
19087   arg2 = &arg2_str;
19088   {
19089     try {
19090       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
19091     } catch (std::out_of_range& e) {
19092       {
19093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19094       };
19095     } catch (std::exception& e) {
19096       {
19097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19098       };
19099     } catch (...) {
19100       {
19101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19102       };
19103     }
19104   }
19105   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19106
19107   //argout typemap for const std::string&
19108
19109   return jresult;
19110 }
19111
19112
19113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
19114   void * jresult ;
19115   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19116   std::type_info *arg2 = 0 ;
19117   Dali::TypeInfo result;
19118
19119   arg1 = (Dali::TypeRegistry *)jarg1;
19120   arg2 = (std::type_info *)jarg2;
19121   if (!arg2) {
19122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19123     return 0;
19124   }
19125   {
19126     try {
19127       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
19128     } catch (std::out_of_range& e) {
19129       {
19130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19131       };
19132     } catch (std::exception& e) {
19133       {
19134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19135       };
19136     } catch (...) {
19137       {
19138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19139       };
19140     }
19141   }
19142   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19143   return jresult;
19144 }
19145
19146
19147 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
19148   unsigned long jresult ;
19149   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19150   size_t result;
19151
19152   arg1 = (Dali::TypeRegistry *)jarg1;
19153   {
19154     try {
19155       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
19156     } catch (std::out_of_range& e) {
19157       {
19158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19159       };
19160     } catch (std::exception& e) {
19161       {
19162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19163       };
19164     } catch (...) {
19165       {
19166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19167       };
19168     }
19169   }
19170   jresult = (unsigned long)result;
19171   return jresult;
19172 }
19173
19174
19175 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
19176   char * jresult ;
19177   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19178   size_t arg2 ;
19179   std::string result;
19180
19181   arg1 = (Dali::TypeRegistry *)jarg1;
19182   arg2 = (size_t)jarg2;
19183   {
19184     try {
19185       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
19186     } catch (std::out_of_range& e) {
19187       {
19188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19189       };
19190     } catch (std::exception& e) {
19191       {
19192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19193       };
19194     } catch (...) {
19195       {
19196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19197       };
19198     }
19199   }
19200   jresult = SWIG_csharp_string_callback((&result)->c_str());
19201   return jresult;
19202 }
19203
19204
19205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_2(void * jarg1) {
19206   void * jresult ;
19207   Dali::Internal::TypeRegistry *arg1 = (Dali::Internal::TypeRegistry *) 0 ;
19208   Dali::TypeRegistry *result = 0 ;
19209
19210   arg1 = (Dali::Internal::TypeRegistry *)jarg1;
19211   {
19212     try {
19213       result = (Dali::TypeRegistry *)new Dali::TypeRegistry(arg1);
19214     } catch (std::out_of_range& e) {
19215       {
19216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19217       };
19218     } catch (std::exception& e) {
19219       {
19220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19221       };
19222     } catch (...) {
19223       {
19224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19225       };
19226     }
19227   }
19228   jresult = (void *)result;
19229   return jresult;
19230 }
19231
19232
19233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
19234   void * jresult ;
19235   std::type_info *arg1 = 0 ;
19236   std::type_info *arg2 = 0 ;
19237   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19238   Dali::TypeRegistration *result = 0 ;
19239
19240   arg1 = (std::type_info *)jarg1;
19241   if (!arg1) {
19242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19243     return 0;
19244   }
19245   arg2 = (std::type_info *)jarg2;
19246   if (!arg2) {
19247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19248     return 0;
19249   }
19250   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19251   {
19252     try {
19253       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
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 = (void *)result;
19269   return jresult;
19270 }
19271
19272
19273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
19274   void * jresult ;
19275   std::type_info *arg1 = 0 ;
19276   std::type_info *arg2 = 0 ;
19277   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19278   bool arg4 ;
19279   Dali::TypeRegistration *result = 0 ;
19280
19281   arg1 = (std::type_info *)jarg1;
19282   if (!arg1) {
19283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19284     return 0;
19285   }
19286   arg2 = (std::type_info *)jarg2;
19287   if (!arg2) {
19288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19289     return 0;
19290   }
19291   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19292   arg4 = jarg4 ? true : false;
19293   {
19294     try {
19295       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
19296     } catch (std::out_of_range& e) {
19297       {
19298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19299       };
19300     } catch (std::exception& e) {
19301       {
19302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19303       };
19304     } catch (...) {
19305       {
19306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19307       };
19308     }
19309   }
19310   jresult = (void *)result;
19311   return jresult;
19312 }
19313
19314
19315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
19316   void * jresult ;
19317   std::string *arg1 = 0 ;
19318   std::type_info *arg2 = 0 ;
19319   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19320   Dali::TypeRegistration *result = 0 ;
19321
19322   if (!jarg1) {
19323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19324     return 0;
19325   }
19326   std::string arg1_str(jarg1);
19327   arg1 = &arg1_str;
19328   arg2 = (std::type_info *)jarg2;
19329   if (!arg2) {
19330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19331     return 0;
19332   }
19333   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19334   {
19335     try {
19336       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
19337     } catch (std::out_of_range& e) {
19338       {
19339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19340       };
19341     } catch (std::exception& e) {
19342       {
19343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19344       };
19345     } catch (...) {
19346       {
19347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19348       };
19349     }
19350   }
19351   jresult = (void *)result;
19352
19353   //argout typemap for const std::string&
19354
19355   return jresult;
19356 }
19357
19358
19359 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
19360   char * jresult ;
19361   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19362   std::string result;
19363
19364   arg1 = (Dali::TypeRegistration *)jarg1;
19365   {
19366     try {
19367       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
19368     } catch (std::out_of_range& e) {
19369       {
19370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19371       };
19372     } catch (std::exception& e) {
19373       {
19374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19375       };
19376     } catch (...) {
19377       {
19378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19379       };
19380     }
19381   }
19382   jresult = SWIG_csharp_string_callback((&result)->c_str());
19383   return jresult;
19384 }
19385
19386
19387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
19388   std::string *arg1 = 0 ;
19389   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
19390
19391   if (!jarg1) {
19392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19393     return ;
19394   }
19395   std::string arg1_str(jarg1);
19396   arg1 = &arg1_str;
19397   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
19398   {
19399     try {
19400       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
19401     } catch (std::out_of_range& e) {
19402       {
19403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19404       };
19405     } catch (std::exception& e) {
19406       {
19407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19408       };
19409     } catch (...) {
19410       {
19411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19412       };
19413     }
19414   }
19415
19416   //argout typemap for const std::string&
19417
19418 }
19419
19420
19421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19422   std::string *arg1 = 0 ;
19423   std::string *arg2 = 0 ;
19424   int arg3 ;
19425   Dali::Property::Type arg4 ;
19426   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
19427   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
19428
19429   if (!jarg1) {
19430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19431     return ;
19432   }
19433   std::string arg1_str(jarg1);
19434   arg1 = &arg1_str;
19435   if (!jarg2) {
19436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19437     return ;
19438   }
19439   std::string arg2_str(jarg2);
19440   arg2 = &arg2_str;
19441   arg3 = (int)jarg3;
19442   arg4 = (Dali::Property::Type)jarg4;
19443   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
19444   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
19445   {
19446     try {
19447       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19448     } catch (std::out_of_range& e) {
19449       {
19450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19451       };
19452     } catch (std::exception& e) {
19453       {
19454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19455       };
19456     } catch (...) {
19457       {
19458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19459       };
19460     }
19461   }
19462
19463   //argout typemap for const std::string&
19464
19465
19466   //argout typemap for const std::string&
19467
19468 }
19469
19470
19471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
19472   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19473
19474   arg1 = (Dali::TypeRegistration *)jarg1;
19475   {
19476     try {
19477       delete arg1;
19478     } catch (std::out_of_range& e) {
19479       {
19480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19481       };
19482     } catch (std::exception& e) {
19483       {
19484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19485       };
19486     } catch (...) {
19487       {
19488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19489       };
19490     }
19491   }
19492 }
19493
19494
19495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
19496   void * jresult ;
19497   Dali::TypeRegistration *arg1 = 0 ;
19498   std::string *arg2 = 0 ;
19499   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
19500   Dali::SignalConnectorType *result = 0 ;
19501
19502   arg1 = (Dali::TypeRegistration *)jarg1;
19503   if (!arg1) {
19504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19505     return 0;
19506   }
19507   if (!jarg2) {
19508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19509     return 0;
19510   }
19511   std::string arg2_str(jarg2);
19512   arg2 = &arg2_str;
19513   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
19514   {
19515     try {
19516       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
19517     } catch (std::out_of_range& e) {
19518       {
19519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19520       };
19521     } catch (std::exception& e) {
19522       {
19523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19524       };
19525     } catch (...) {
19526       {
19527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19528       };
19529     }
19530   }
19531   jresult = (void *)result;
19532
19533   //argout typemap for const std::string&
19534
19535   return jresult;
19536 }
19537
19538
19539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
19540   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
19541
19542   arg1 = (Dali::SignalConnectorType *)jarg1;
19543   {
19544     try {
19545       delete arg1;
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
19562
19563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
19564   void * jresult ;
19565   Dali::TypeRegistration *arg1 = 0 ;
19566   std::string *arg2 = 0 ;
19567   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
19568   Dali::TypeAction *result = 0 ;
19569
19570   arg1 = (Dali::TypeRegistration *)jarg1;
19571   if (!arg1) {
19572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19573     return 0;
19574   }
19575   if (!jarg2) {
19576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19577     return 0;
19578   }
19579   std::string arg2_str(jarg2);
19580   arg2 = &arg2_str;
19581   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
19582   {
19583     try {
19584       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
19585     } catch (std::out_of_range& e) {
19586       {
19587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19588       };
19589     } catch (std::exception& e) {
19590       {
19591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19592       };
19593     } catch (...) {
19594       {
19595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19596       };
19597     }
19598   }
19599   jresult = (void *)result;
19600
19601   //argout typemap for const std::string&
19602
19603   return jresult;
19604 }
19605
19606
19607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
19608   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
19609
19610   arg1 = (Dali::TypeAction *)jarg1;
19611   {
19612     try {
19613       delete arg1;
19614     } catch (std::out_of_range& e) {
19615       {
19616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19617       };
19618     } catch (std::exception& e) {
19619       {
19620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19621       };
19622     } catch (...) {
19623       {
19624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19625       };
19626     }
19627   }
19628 }
19629
19630
19631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19632   void * jresult ;
19633   Dali::TypeRegistration *arg1 = 0 ;
19634   std::string *arg2 = 0 ;
19635   Dali::Property::Index arg3 ;
19636   Dali::Property::Type arg4 ;
19637   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
19638   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
19639   Dali::PropertyRegistration *result = 0 ;
19640
19641   arg1 = (Dali::TypeRegistration *)jarg1;
19642   if (!arg1) {
19643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19644     return 0;
19645   }
19646   if (!jarg2) {
19647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19648     return 0;
19649   }
19650   std::string arg2_str(jarg2);
19651   arg2 = &arg2_str;
19652   arg3 = (Dali::Property::Index)jarg3;
19653   arg4 = (Dali::Property::Type)jarg4;
19654   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
19655   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
19656   {
19657     try {
19658       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19659     } catch (std::out_of_range& e) {
19660       {
19661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19662       };
19663     } catch (std::exception& e) {
19664       {
19665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19666       };
19667     } catch (...) {
19668       {
19669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19670       };
19671     }
19672   }
19673   jresult = (void *)result;
19674
19675   //argout typemap for const std::string&
19676
19677   return jresult;
19678 }
19679
19680
19681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
19682   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
19683
19684   arg1 = (Dali::PropertyRegistration *)jarg1;
19685   {
19686     try {
19687       delete arg1;
19688     } catch (std::out_of_range& e) {
19689       {
19690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19691       };
19692     } catch (std::exception& e) {
19693       {
19694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19695       };
19696     } catch (...) {
19697       {
19698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19699       };
19700     }
19701   }
19702 }
19703
19704
19705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19706   void * jresult ;
19707   Dali::TypeRegistration *arg1 = 0 ;
19708   std::string *arg2 = 0 ;
19709   Dali::Property::Index arg3 ;
19710   Dali::Property::Type arg4 ;
19711   Dali::AnimatablePropertyRegistration *result = 0 ;
19712
19713   arg1 = (Dali::TypeRegistration *)jarg1;
19714   if (!arg1) {
19715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19716     return 0;
19717   }
19718   if (!jarg2) {
19719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19720     return 0;
19721   }
19722   std::string arg2_str(jarg2);
19723   arg2 = &arg2_str;
19724   arg3 = (Dali::Property::Index)jarg3;
19725   arg4 = (Dali::Property::Type)jarg4;
19726   {
19727     try {
19728       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19729     } catch (std::out_of_range& e) {
19730       {
19731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19732       };
19733     } catch (std::exception& e) {
19734       {
19735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19736       };
19737     } catch (...) {
19738       {
19739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19740       };
19741     }
19742   }
19743   jresult = (void *)result;
19744
19745   //argout typemap for const std::string&
19746
19747   return jresult;
19748 }
19749
19750
19751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
19752   void * jresult ;
19753   Dali::TypeRegistration *arg1 = 0 ;
19754   std::string *arg2 = 0 ;
19755   Dali::Property::Index arg3 ;
19756   Dali::Property::Value *arg4 = 0 ;
19757   Dali::AnimatablePropertyRegistration *result = 0 ;
19758
19759   arg1 = (Dali::TypeRegistration *)jarg1;
19760   if (!arg1) {
19761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19762     return 0;
19763   }
19764   if (!jarg2) {
19765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19766     return 0;
19767   }
19768   std::string arg2_str(jarg2);
19769   arg2 = &arg2_str;
19770   arg3 = (Dali::Property::Index)jarg3;
19771   arg4 = (Dali::Property::Value *)jarg4;
19772   if (!arg4) {
19773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
19774     return 0;
19775   }
19776   {
19777     try {
19778       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
19779     } catch (std::out_of_range& e) {
19780       {
19781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19782       };
19783     } catch (std::exception& e) {
19784       {
19785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19786       };
19787     } catch (...) {
19788       {
19789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19790       };
19791     }
19792   }
19793   jresult = (void *)result;
19794
19795   //argout typemap for const std::string&
19796
19797   return jresult;
19798 }
19799
19800
19801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
19802   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
19803
19804   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
19805   {
19806     try {
19807       delete arg1;
19808     } catch (std::out_of_range& e) {
19809       {
19810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19811       };
19812     } catch (std::exception& e) {
19813       {
19814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19815       };
19816     } catch (...) {
19817       {
19818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19819       };
19820     }
19821   }
19822 }
19823
19824
19825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
19826   void * jresult ;
19827   Dali::TypeRegistration *arg1 = 0 ;
19828   std::string *arg2 = 0 ;
19829   Dali::Property::Index arg3 ;
19830   Dali::Property::Index arg4 ;
19831   unsigned int arg5 ;
19832   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
19833
19834   arg1 = (Dali::TypeRegistration *)jarg1;
19835   if (!arg1) {
19836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19837     return 0;
19838   }
19839   if (!jarg2) {
19840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19841     return 0;
19842   }
19843   std::string arg2_str(jarg2);
19844   arg2 = &arg2_str;
19845   arg3 = (Dali::Property::Index)jarg3;
19846   arg4 = (Dali::Property::Index)jarg4;
19847   arg5 = (unsigned int)jarg5;
19848   {
19849     try {
19850       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
19851     } catch (std::out_of_range& e) {
19852       {
19853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19854       };
19855     } catch (std::exception& e) {
19856       {
19857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19858       };
19859     } catch (...) {
19860       {
19861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19862       };
19863     }
19864   }
19865   jresult = (void *)result;
19866
19867   //argout typemap for const std::string&
19868
19869   return jresult;
19870 }
19871
19872
19873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
19874   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
19875
19876   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
19877   {
19878     try {
19879       delete arg1;
19880     } catch (std::out_of_range& e) {
19881       {
19882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19883       };
19884     } catch (std::exception& e) {
19885       {
19886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19887       };
19888     } catch (...) {
19889       {
19890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19891       };
19892     }
19893   }
19894 }
19895
19896
19897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19898   void * jresult ;
19899   Dali::TypeRegistration *arg1 = 0 ;
19900   std::string *arg2 = 0 ;
19901   Dali::Property::Index arg3 ;
19902   Dali::Property::Type arg4 ;
19903   Dali::ChildPropertyRegistration *result = 0 ;
19904
19905   arg1 = (Dali::TypeRegistration *)jarg1;
19906   if (!arg1) {
19907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19908     return 0;
19909   }
19910   if (!jarg2) {
19911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19912     return 0;
19913   }
19914   std::string arg2_str(jarg2);
19915   arg2 = &arg2_str;
19916   arg3 = (Dali::Property::Index)jarg3;
19917   arg4 = (Dali::Property::Type)jarg4;
19918   {
19919     try {
19920       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19921     } catch (std::out_of_range& e) {
19922       {
19923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19924       };
19925     } catch (std::exception& e) {
19926       {
19927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19928       };
19929     } catch (...) {
19930       {
19931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19932       };
19933     }
19934   }
19935   jresult = (void *)result;
19936
19937   //argout typemap for const std::string&
19938
19939   return jresult;
19940 }
19941
19942
19943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
19944   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
19945
19946   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
19947   {
19948     try {
19949       delete arg1;
19950     } catch (std::out_of_range& e) {
19951       {
19952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19953       };
19954     } catch (std::exception& e) {
19955       {
19956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19957       };
19958     } catch (...) {
19959       {
19960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19961       };
19962     }
19963   }
19964 }
19965
19966
19967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
19968   unsigned int jresult ;
19969   std::string *arg1 = 0 ;
19970   std::type_info *arg2 = 0 ;
19971   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
19972   bool result;
19973
19974   if (!jarg1) {
19975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19976     return 0;
19977   }
19978   std::string arg1_str(jarg1);
19979   arg1 = &arg1_str;
19980   arg2 = (std::type_info *)jarg2;
19981   if (!arg2) {
19982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19983     return 0;
19984   }
19985   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
19986   {
19987     try {
19988       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
19989     } catch (std::out_of_range& e) {
19990       {
19991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19992       };
19993     } catch (std::exception& e) {
19994       {
19995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19996       };
19997     } catch (...) {
19998       {
19999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20000       };
20001     }
20002   }
20003   jresult = result;
20004
20005   //argout typemap for const std::string&
20006
20007   return jresult;
20008 }
20009
20010
20011 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
20012   unsigned int jresult ;
20013   std::string *arg1 = 0 ;
20014   std::string *arg2 = 0 ;
20015   Dali::Property::Index arg3 ;
20016   Dali::Property::Type arg4 ;
20017   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
20018   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
20019   bool result;
20020
20021   if (!jarg1) {
20022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20023     return 0;
20024   }
20025   std::string arg1_str(jarg1);
20026   arg1 = &arg1_str;
20027   if (!jarg2) {
20028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20029     return 0;
20030   }
20031   std::string arg2_str(jarg2);
20032   arg2 = &arg2_str;
20033   arg3 = (Dali::Property::Index)jarg3;
20034   arg4 = (Dali::Property::Type)jarg4;
20035   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
20036   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
20037   {
20038     try {
20039       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
20040     } catch (std::out_of_range& e) {
20041       {
20042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20043       };
20044     } catch (std::exception& e) {
20045       {
20046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20047       };
20048     } catch (...) {
20049       {
20050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20051       };
20052     }
20053   }
20054   jresult = result;
20055
20056   //argout typemap for const std::string&
20057
20058
20059   //argout typemap for const std::string&
20060
20061   return jresult;
20062 }
20063
20064
20065 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
20066   float jresult ;
20067   float result;
20068
20069   result = (float)(float)Dali::ParentOrigin::TOP;
20070   jresult = result;
20071   return jresult;
20072 }
20073
20074
20075 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
20076   float jresult ;
20077   float result;
20078
20079   result = (float)(float)Dali::ParentOrigin::BOTTOM;
20080   jresult = result;
20081   return jresult;
20082 }
20083
20084
20085 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
20086   float jresult ;
20087   float result;
20088
20089   result = (float)(float)Dali::ParentOrigin::LEFT;
20090   jresult = result;
20091   return jresult;
20092 }
20093
20094
20095 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
20096   float jresult ;
20097   float result;
20098
20099   result = (float)(float)Dali::ParentOrigin::RIGHT;
20100   jresult = result;
20101   return jresult;
20102 }
20103
20104
20105 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
20106   float jresult ;
20107   float result;
20108
20109   result = (float)(float)Dali::ParentOrigin::MIDDLE;
20110   jresult = result;
20111   return jresult;
20112 }
20113
20114
20115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
20116   void * jresult ;
20117   Dali::Vector3 *result = 0 ;
20118
20119   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
20120   jresult = (void *)result;
20121   return jresult;
20122 }
20123
20124
20125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
20126   void * jresult ;
20127   Dali::Vector3 *result = 0 ;
20128
20129   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
20130   jresult = (void *)result;
20131   return jresult;
20132 }
20133
20134
20135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
20136   void * jresult ;
20137   Dali::Vector3 *result = 0 ;
20138
20139   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
20140   jresult = (void *)result;
20141   return jresult;
20142 }
20143
20144
20145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
20146   void * jresult ;
20147   Dali::Vector3 *result = 0 ;
20148
20149   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
20150   jresult = (void *)result;
20151   return jresult;
20152 }
20153
20154
20155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
20156   void * jresult ;
20157   Dali::Vector3 *result = 0 ;
20158
20159   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
20160   jresult = (void *)result;
20161   return jresult;
20162 }
20163
20164
20165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
20166   void * jresult ;
20167   Dali::Vector3 *result = 0 ;
20168
20169   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
20170   jresult = (void *)result;
20171   return jresult;
20172 }
20173
20174
20175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
20176   void * jresult ;
20177   Dali::Vector3 *result = 0 ;
20178
20179   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
20180   jresult = (void *)result;
20181   return jresult;
20182 }
20183
20184
20185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
20186   void * jresult ;
20187   Dali::Vector3 *result = 0 ;
20188
20189   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
20190   jresult = (void *)result;
20191   return jresult;
20192 }
20193
20194
20195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
20196   void * jresult ;
20197   Dali::Vector3 *result = 0 ;
20198
20199   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
20200   jresult = (void *)result;
20201   return jresult;
20202 }
20203
20204
20205 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
20206   float jresult ;
20207   float result;
20208
20209   result = (float)(float)Dali::AnchorPoint::TOP;
20210   jresult = result;
20211   return jresult;
20212 }
20213
20214
20215 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
20216   float jresult ;
20217   float result;
20218
20219   result = (float)(float)Dali::AnchorPoint::BOTTOM;
20220   jresult = result;
20221   return jresult;
20222 }
20223
20224
20225 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
20226   float jresult ;
20227   float result;
20228
20229   result = (float)(float)Dali::AnchorPoint::LEFT;
20230   jresult = result;
20231   return jresult;
20232 }
20233
20234
20235 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
20236   float jresult ;
20237   float result;
20238
20239   result = (float)(float)Dali::AnchorPoint::RIGHT;
20240   jresult = result;
20241   return jresult;
20242 }
20243
20244
20245 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
20246   float jresult ;
20247   float result;
20248
20249   result = (float)(float)Dali::AnchorPoint::MIDDLE;
20250   jresult = result;
20251   return jresult;
20252 }
20253
20254
20255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
20256   void * jresult ;
20257   Dali::Vector3 *result = 0 ;
20258
20259   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
20260   jresult = (void *)result;
20261   return jresult;
20262 }
20263
20264
20265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
20266   void * jresult ;
20267   Dali::Vector3 *result = 0 ;
20268
20269   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
20270   jresult = (void *)result;
20271   return jresult;
20272 }
20273
20274
20275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
20276   void * jresult ;
20277   Dali::Vector3 *result = 0 ;
20278
20279   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
20280   jresult = (void *)result;
20281   return jresult;
20282 }
20283
20284
20285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
20286   void * jresult ;
20287   Dali::Vector3 *result = 0 ;
20288
20289   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
20290   jresult = (void *)result;
20291   return jresult;
20292 }
20293
20294
20295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
20296   void * jresult ;
20297   Dali::Vector3 *result = 0 ;
20298
20299   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
20300   jresult = (void *)result;
20301   return jresult;
20302 }
20303
20304
20305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
20306   void * jresult ;
20307   Dali::Vector3 *result = 0 ;
20308
20309   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
20310   jresult = (void *)result;
20311   return jresult;
20312 }
20313
20314
20315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
20316   void * jresult ;
20317   Dali::Vector3 *result = 0 ;
20318
20319   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
20320   jresult = (void *)result;
20321   return jresult;
20322 }
20323
20324
20325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
20326   void * jresult ;
20327   Dali::Vector3 *result = 0 ;
20328
20329   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
20330   jresult = (void *)result;
20331   return jresult;
20332 }
20333
20334
20335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
20336   void * jresult ;
20337   Dali::Vector3 *result = 0 ;
20338
20339   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
20340   jresult = (void *)result;
20341   return jresult;
20342 }
20343
20344
20345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
20346   void * jresult ;
20347   Dali::Vector4 *result = 0 ;
20348
20349   result = (Dali::Vector4 *)&Dali::Color::BLACK;
20350   jresult = (void *)result;
20351   return jresult;
20352 }
20353
20354
20355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
20356   void * jresult ;
20357   Dali::Vector4 *result = 0 ;
20358
20359   result = (Dali::Vector4 *)&Dali::Color::WHITE;
20360   jresult = (void *)result;
20361   return jresult;
20362 }
20363
20364
20365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
20366   void * jresult ;
20367   Dali::Vector4 *result = 0 ;
20368
20369   result = (Dali::Vector4 *)&Dali::Color::RED;
20370   jresult = (void *)result;
20371   return jresult;
20372 }
20373
20374
20375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
20376   void * jresult ;
20377   Dali::Vector4 *result = 0 ;
20378
20379   result = (Dali::Vector4 *)&Dali::Color::GREEN;
20380   jresult = (void *)result;
20381   return jresult;
20382 }
20383
20384
20385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
20386   void * jresult ;
20387   Dali::Vector4 *result = 0 ;
20388
20389   result = (Dali::Vector4 *)&Dali::Color::BLUE;
20390   jresult = (void *)result;
20391   return jresult;
20392 }
20393
20394
20395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
20396   void * jresult ;
20397   Dali::Vector4 *result = 0 ;
20398
20399   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
20400   jresult = (void *)result;
20401   return jresult;
20402 }
20403
20404
20405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
20406   void * jresult ;
20407   Dali::Vector4 *result = 0 ;
20408
20409   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
20410   jresult = (void *)result;
20411   return jresult;
20412 }
20413
20414
20415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
20416   void * jresult ;
20417   Dali::Vector4 *result = 0 ;
20418
20419   result = (Dali::Vector4 *)&Dali::Color::CYAN;
20420   jresult = (void *)result;
20421   return jresult;
20422 }
20423
20424
20425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
20426   void * jresult ;
20427   Dali::Vector4 *result = 0 ;
20428
20429   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
20430   jresult = (void *)result;
20431   return jresult;
20432 }
20433
20434
20435 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
20436   float jresult ;
20437   float result;
20438
20439   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
20440   jresult = result;
20441   return jresult;
20442 }
20443
20444
20445 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
20446   float jresult ;
20447   float result;
20448
20449   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
20450   jresult = result;
20451   return jresult;
20452 }
20453
20454
20455 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
20456   float jresult ;
20457   float result;
20458
20459   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
20460   jresult = result;
20461   return jresult;
20462 }
20463
20464
20465 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
20466   float jresult ;
20467   float result;
20468
20469   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
20470   jresult = result;
20471   return jresult;
20472 }
20473
20474
20475 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
20476   float jresult ;
20477   float result;
20478
20479   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
20480   jresult = result;
20481   return jresult;
20482 }
20483
20484
20485 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
20486   float jresult ;
20487   float result;
20488
20489   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
20490   jresult = result;
20491   return jresult;
20492 }
20493
20494
20495 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
20496   float jresult ;
20497   float result;
20498
20499   result = (float)(float)Dali::Math::PI;
20500   jresult = result;
20501   return jresult;
20502 }
20503
20504
20505 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
20506   float jresult ;
20507   float result;
20508
20509   result = (float)(float)Dali::Math::PI_2;
20510   jresult = result;
20511   return jresult;
20512 }
20513
20514
20515 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
20516   float jresult ;
20517   float result;
20518
20519   result = (float)(float)Dali::Math::PI_4;
20520   jresult = result;
20521   return jresult;
20522 }
20523
20524
20525 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
20526   float jresult ;
20527   float result;
20528
20529   result = (float)(float)Dali::Math::PI_OVER_180;
20530   jresult = result;
20531   return jresult;
20532 }
20533
20534
20535 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
20536   float jresult ;
20537   float result;
20538
20539   result = (float)(float)Dali::Math::ONE80_OVER_PI;
20540   jresult = result;
20541   return jresult;
20542 }
20543
20544
20545 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
20546   int jresult ;
20547   Dali::ResizePolicy::Type result;
20548
20549   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
20550   jresult = (int)result;
20551   return jresult;
20552 }
20553
20554
20555 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
20556   unsigned long jresult ;
20557   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20558   Dali::VectorBase::SizeType result;
20559
20560   arg1 = (Dali::VectorBase *)jarg1;
20561   {
20562     try {
20563       result = ((Dali::VectorBase const *)arg1)->Count();
20564     } catch (std::out_of_range& e) {
20565       {
20566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20567       };
20568     } catch (std::exception& e) {
20569       {
20570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20571       };
20572     } catch (...) {
20573       {
20574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20575       };
20576     }
20577   }
20578   jresult = (unsigned long)result;
20579   return jresult;
20580 }
20581
20582
20583 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
20584   unsigned long jresult ;
20585   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20586   Dali::VectorBase::SizeType result;
20587
20588   arg1 = (Dali::VectorBase *)jarg1;
20589   {
20590     try {
20591       result = ((Dali::VectorBase const *)arg1)->Size();
20592     } catch (std::out_of_range& e) {
20593       {
20594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20595       };
20596     } catch (std::exception& e) {
20597       {
20598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20599       };
20600     } catch (...) {
20601       {
20602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20603       };
20604     }
20605   }
20606   jresult = (unsigned long)result;
20607   return jresult;
20608 }
20609
20610
20611 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
20612   unsigned int jresult ;
20613   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20614   bool result;
20615
20616   arg1 = (Dali::VectorBase *)jarg1;
20617   {
20618     try {
20619       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
20620     } catch (std::out_of_range& e) {
20621       {
20622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20623       };
20624     } catch (std::exception& e) {
20625       {
20626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20627       };
20628     } catch (...) {
20629       {
20630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20631       };
20632     }
20633   }
20634   jresult = result;
20635   return jresult;
20636 }
20637
20638
20639 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
20640   unsigned long jresult ;
20641   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20642   Dali::VectorBase::SizeType result;
20643
20644   arg1 = (Dali::VectorBase *)jarg1;
20645   {
20646     try {
20647       result = ((Dali::VectorBase const *)arg1)->Capacity();
20648     } catch (std::out_of_range& e) {
20649       {
20650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20651       };
20652     } catch (std::exception& e) {
20653       {
20654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20655       };
20656     } catch (...) {
20657       {
20658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20659       };
20660     }
20661   }
20662   jresult = (unsigned long)result;
20663   return jresult;
20664 }
20665
20666
20667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
20668   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20669
20670   arg1 = (Dali::VectorBase *)jarg1;
20671   {
20672     try {
20673       (arg1)->Release();
20674     } catch (std::out_of_range& e) {
20675       {
20676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20677       };
20678     } catch (std::exception& e) {
20679       {
20680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20681       };
20682     } catch (...) {
20683       {
20684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20685       };
20686     }
20687   }
20688 }
20689
20690
20691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
20692   void * jresult ;
20693   Dali::Image *result = 0 ;
20694
20695   {
20696     try {
20697       result = (Dali::Image *)new Dali::Image();
20698     } catch (std::out_of_range& e) {
20699       {
20700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20701       };
20702     } catch (std::exception& e) {
20703       {
20704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20705       };
20706     } catch (...) {
20707       {
20708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20709       };
20710     }
20711   }
20712   jresult = (void *)result;
20713   return jresult;
20714 }
20715
20716
20717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
20718   Dali::Image *arg1 = (Dali::Image *) 0 ;
20719
20720   arg1 = (Dali::Image *)jarg1;
20721   {
20722     try {
20723       delete arg1;
20724     } catch (std::out_of_range& e) {
20725       {
20726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20727       };
20728     } catch (std::exception& e) {
20729       {
20730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20731       };
20732     } catch (...) {
20733       {
20734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20735       };
20736     }
20737   }
20738 }
20739
20740
20741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
20742   void * jresult ;
20743   Dali::Image *arg1 = 0 ;
20744   Dali::Image *result = 0 ;
20745
20746   arg1 = (Dali::Image *)jarg1;
20747   if (!arg1) {
20748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20749     return 0;
20750   }
20751   {
20752     try {
20753       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
20754     } catch (std::out_of_range& e) {
20755       {
20756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20757       };
20758     } catch (std::exception& e) {
20759       {
20760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20761       };
20762     } catch (...) {
20763       {
20764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20765       };
20766     }
20767   }
20768   jresult = (void *)result;
20769   return jresult;
20770 }
20771
20772
20773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
20774   void * jresult ;
20775   Dali::Image *arg1 = (Dali::Image *) 0 ;
20776   Dali::Image *arg2 = 0 ;
20777   Dali::Image *result = 0 ;
20778
20779   arg1 = (Dali::Image *)jarg1;
20780   arg2 = (Dali::Image *)jarg2;
20781   if (!arg2) {
20782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20783     return 0;
20784   }
20785   {
20786     try {
20787       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
20788     } catch (std::out_of_range& e) {
20789       {
20790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20791       };
20792     } catch (std::exception& e) {
20793       {
20794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20795       };
20796     } catch (...) {
20797       {
20798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20799       };
20800     }
20801   }
20802   jresult = (void *)result;
20803   return jresult;
20804 }
20805
20806
20807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
20808   void * jresult ;
20809   Dali::BaseHandle arg1 ;
20810   Dali::BaseHandle *argp1 ;
20811   Dali::Image result;
20812
20813   argp1 = (Dali::BaseHandle *)jarg1;
20814   if (!argp1) {
20815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20816     return 0;
20817   }
20818   arg1 = *argp1;
20819   {
20820     try {
20821       result = Dali::Image::DownCast(arg1);
20822     } catch (std::out_of_range& e) {
20823       {
20824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20825       };
20826     } catch (std::exception& e) {
20827       {
20828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20829       };
20830     } catch (...) {
20831       {
20832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20833       };
20834     }
20835   }
20836   jresult = new Dali::Image((const Dali::Image &)result);
20837   return jresult;
20838 }
20839
20840
20841 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
20842   unsigned int jresult ;
20843   Dali::Image *arg1 = (Dali::Image *) 0 ;
20844   unsigned int result;
20845
20846   arg1 = (Dali::Image *)jarg1;
20847   {
20848     try {
20849       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
20850     } catch (std::out_of_range& e) {
20851       {
20852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20853       };
20854     } catch (std::exception& e) {
20855       {
20856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20857       };
20858     } catch (...) {
20859       {
20860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20861       };
20862     }
20863   }
20864   jresult = result;
20865   return jresult;
20866 }
20867
20868
20869 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
20870   unsigned int jresult ;
20871   Dali::Image *arg1 = (Dali::Image *) 0 ;
20872   unsigned int result;
20873
20874   arg1 = (Dali::Image *)jarg1;
20875   {
20876     try {
20877       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
20878     } catch (std::out_of_range& e) {
20879       {
20880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20881       };
20882     } catch (std::exception& e) {
20883       {
20884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20885       };
20886     } catch (...) {
20887       {
20888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20889       };
20890     }
20891   }
20892   jresult = result;
20893   return jresult;
20894 }
20895
20896
20897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
20898   void * jresult ;
20899   Dali::Image *arg1 = (Dali::Image *) 0 ;
20900   Dali::Image::ImageSignalType *result = 0 ;
20901
20902   arg1 = (Dali::Image *)jarg1;
20903   {
20904     try {
20905       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
20906     } catch (std::out_of_range& e) {
20907       {
20908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20909       };
20910     } catch (std::exception& e) {
20911       {
20912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20913       };
20914     } catch (...) {
20915       {
20916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20917       };
20918     }
20919   }
20920   jresult = (void *)result;
20921   return jresult;
20922 }
20923
20924
20925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
20926   int jresult ;
20927   Dali::Pixel::Format result;
20928
20929   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
20930   jresult = (int)result;
20931   return jresult;
20932 }
20933
20934
20935 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
20936   int jresult ;
20937   Dali::Pixel::Format result;
20938
20939   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
20940   jresult = (int)result;
20941   return jresult;
20942 }
20943
20944
20945 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
20946   unsigned int jresult ;
20947   Dali::Pixel::Format arg1 ;
20948   bool result;
20949
20950   arg1 = (Dali::Pixel::Format)jarg1;
20951   {
20952     try {
20953       result = (bool)Dali::Pixel::HasAlpha(arg1);
20954     } catch (std::out_of_range& e) {
20955       {
20956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20957       };
20958     } catch (std::exception& e) {
20959       {
20960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20961       };
20962     } catch (...) {
20963       {
20964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20965       };
20966     }
20967   }
20968   jresult = result;
20969   return jresult;
20970 }
20971
20972
20973 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
20974   unsigned int jresult ;
20975   Dali::Pixel::Format arg1 ;
20976   unsigned int result;
20977
20978   arg1 = (Dali::Pixel::Format)jarg1;
20979   {
20980     try {
20981       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
20982     } catch (std::out_of_range& e) {
20983       {
20984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20985       };
20986     } catch (std::exception& e) {
20987       {
20988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20989       };
20990     } catch (...) {
20991       {
20992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20993       };
20994     }
20995   }
20996   jresult = result;
20997   return jresult;
20998 }
20999
21000
21001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
21002   Dali::Pixel::Format arg1 ;
21003   int *arg2 = 0 ;
21004   int *arg3 = 0 ;
21005
21006   arg1 = (Dali::Pixel::Format)jarg1;
21007   arg2 = (int *)jarg2;
21008   if (!arg2) {
21009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21010     return ;
21011   }
21012   arg3 = (int *)jarg3;
21013   if (!arg3) {
21014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21015     return ;
21016   }
21017   {
21018     try {
21019       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
21020     } catch (std::out_of_range& e) {
21021       {
21022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21023       };
21024     } catch (std::exception& e) {
21025       {
21026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21027       };
21028     } catch (...) {
21029       {
21030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21031       };
21032     }
21033   }
21034 }
21035
21036
21037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
21038   void * jresult ;
21039   unsigned char *arg1 = (unsigned char *) 0 ;
21040   unsigned int arg2 ;
21041   unsigned int arg3 ;
21042   unsigned int arg4 ;
21043   Dali::Pixel::Format arg5 ;
21044   Dali::PixelData::ReleaseFunction arg6 ;
21045   Dali::PixelData result;
21046
21047   arg1 = jarg1;
21048   arg2 = (unsigned int)jarg2;
21049   arg3 = (unsigned int)jarg3;
21050   arg4 = (unsigned int)jarg4;
21051   arg5 = (Dali::Pixel::Format)jarg5;
21052   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
21053   {
21054     try {
21055       result = Dali::PixelData::New(arg1,arg2,arg3,arg4,arg5,arg6);
21056     } catch (std::out_of_range& e) {
21057       {
21058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21059       };
21060     } catch (std::exception& e) {
21061       {
21062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21063       };
21064     } catch (...) {
21065       {
21066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21067       };
21068     }
21069   }
21070   jresult = new Dali::PixelData((const Dali::PixelData &)result);
21071
21072
21073   return jresult;
21074 }
21075
21076
21077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
21078   void * jresult ;
21079   Dali::PixelData *result = 0 ;
21080
21081   {
21082     try {
21083       result = (Dali::PixelData *)new Dali::PixelData();
21084     } catch (std::out_of_range& e) {
21085       {
21086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21087       };
21088     } catch (std::exception& e) {
21089       {
21090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21091       };
21092     } catch (...) {
21093       {
21094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21095       };
21096     }
21097   }
21098   jresult = (void *)result;
21099   return jresult;
21100 }
21101
21102
21103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
21104   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21105
21106   arg1 = (Dali::PixelData *)jarg1;
21107   {
21108     try {
21109       delete arg1;
21110     } catch (std::out_of_range& e) {
21111       {
21112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21113       };
21114     } catch (std::exception& e) {
21115       {
21116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21117       };
21118     } catch (...) {
21119       {
21120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21121       };
21122     }
21123   }
21124 }
21125
21126
21127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
21128   void * jresult ;
21129   Dali::PixelData *arg1 = 0 ;
21130   Dali::PixelData *result = 0 ;
21131
21132   arg1 = (Dali::PixelData *)jarg1;
21133   if (!arg1) {
21134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21135     return 0;
21136   }
21137   {
21138     try {
21139       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
21140     } catch (std::out_of_range& e) {
21141       {
21142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21143       };
21144     } catch (std::exception& e) {
21145       {
21146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21147       };
21148     } catch (...) {
21149       {
21150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21151       };
21152     }
21153   }
21154   jresult = (void *)result;
21155   return jresult;
21156 }
21157
21158
21159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
21160   void * jresult ;
21161   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21162   Dali::PixelData *arg2 = 0 ;
21163   Dali::PixelData *result = 0 ;
21164
21165   arg1 = (Dali::PixelData *)jarg1;
21166   arg2 = (Dali::PixelData *)jarg2;
21167   if (!arg2) {
21168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21169     return 0;
21170   }
21171   {
21172     try {
21173       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
21174     } catch (std::out_of_range& e) {
21175       {
21176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21177       };
21178     } catch (std::exception& e) {
21179       {
21180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21181       };
21182     } catch (...) {
21183       {
21184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21185       };
21186     }
21187   }
21188   jresult = (void *)result;
21189   return jresult;
21190 }
21191
21192
21193 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
21194   unsigned int jresult ;
21195   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21196   unsigned int result;
21197
21198   arg1 = (Dali::PixelData *)jarg1;
21199   {
21200     try {
21201       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
21202     } catch (std::out_of_range& e) {
21203       {
21204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21205       };
21206     } catch (std::exception& e) {
21207       {
21208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21209       };
21210     } catch (...) {
21211       {
21212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21213       };
21214     }
21215   }
21216   jresult = result;
21217   return jresult;
21218 }
21219
21220
21221 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
21222   unsigned int jresult ;
21223   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21224   unsigned int result;
21225
21226   arg1 = (Dali::PixelData *)jarg1;
21227   {
21228     try {
21229       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
21230     } catch (std::out_of_range& e) {
21231       {
21232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21233       };
21234     } catch (std::exception& e) {
21235       {
21236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21237       };
21238     } catch (...) {
21239       {
21240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21241       };
21242     }
21243   }
21244   jresult = result;
21245   return jresult;
21246 }
21247
21248
21249 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
21250   int jresult ;
21251   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21252   Dali::Pixel::Format result;
21253
21254   arg1 = (Dali::PixelData *)jarg1;
21255   {
21256     try {
21257       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
21258     } catch (std::out_of_range& e) {
21259       {
21260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21261       };
21262     } catch (std::exception& e) {
21263       {
21264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21265       };
21266     } catch (...) {
21267       {
21268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21269       };
21270     }
21271   }
21272   jresult = (int)result;
21273   return jresult;
21274 }
21275
21276
21277 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
21278   unsigned int jresult ;
21279   unsigned int result;
21280
21281   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
21282   jresult = result;
21283   return jresult;
21284 }
21285
21286
21287 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
21288   unsigned int jresult ;
21289   unsigned int result;
21290
21291   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
21292   jresult = result;
21293   return jresult;
21294 }
21295
21296
21297 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
21298   unsigned int jresult ;
21299   unsigned int result;
21300
21301   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
21302   jresult = result;
21303   return jresult;
21304 }
21305
21306
21307 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
21308   unsigned int jresult ;
21309   unsigned int result;
21310
21311   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
21312   jresult = result;
21313   return jresult;
21314 }
21315
21316
21317 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
21318   unsigned int jresult ;
21319   unsigned int result;
21320
21321   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
21322   jresult = result;
21323   return jresult;
21324 }
21325
21326
21327 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
21328   unsigned int jresult ;
21329   unsigned int result;
21330
21331   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
21332   jresult = result;
21333   return jresult;
21334 }
21335
21336
21337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
21338   void * jresult ;
21339   Dali::TextureType::Type arg1 ;
21340   Dali::Pixel::Format arg2 ;
21341   unsigned int arg3 ;
21342   unsigned int arg4 ;
21343   Dali::Texture result;
21344
21345   arg1 = (Dali::TextureType::Type)jarg1;
21346   arg2 = (Dali::Pixel::Format)jarg2;
21347   arg3 = (unsigned int)jarg3;
21348   arg4 = (unsigned int)jarg4;
21349   {
21350     try {
21351       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
21352     } catch (std::out_of_range& e) {
21353       {
21354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21355       };
21356     } catch (std::exception& e) {
21357       {
21358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21359       };
21360     } catch (...) {
21361       {
21362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21363       };
21364     }
21365   }
21366   jresult = new Dali::Texture((const Dali::Texture &)result);
21367   return jresult;
21368 }
21369
21370
21371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
21372   void * jresult ;
21373   NativeImageInterface *arg1 = 0 ;
21374   Dali::Texture result;
21375
21376   arg1 = (NativeImageInterface *)jarg1;
21377   if (!arg1) {
21378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
21379     return 0;
21380   }
21381   {
21382     try {
21383       result = Dali::Texture::New(*arg1);
21384     } catch (std::out_of_range& e) {
21385       {
21386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21387       };
21388     } catch (std::exception& e) {
21389       {
21390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21391       };
21392     } catch (...) {
21393       {
21394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21395       };
21396     }
21397   }
21398   jresult = new Dali::Texture((const Dali::Texture &)result);
21399   return jresult;
21400 }
21401
21402
21403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
21404   void * jresult ;
21405   Dali::Texture *result = 0 ;
21406
21407   {
21408     try {
21409       result = (Dali::Texture *)new Dali::Texture();
21410     } catch (std::out_of_range& e) {
21411       {
21412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21413       };
21414     } catch (std::exception& e) {
21415       {
21416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21417       };
21418     } catch (...) {
21419       {
21420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21421       };
21422     }
21423   }
21424   jresult = (void *)result;
21425   return jresult;
21426 }
21427
21428
21429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
21430   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21431
21432   arg1 = (Dali::Texture *)jarg1;
21433   {
21434     try {
21435       delete arg1;
21436     } catch (std::out_of_range& e) {
21437       {
21438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21439       };
21440     } catch (std::exception& e) {
21441       {
21442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21443       };
21444     } catch (...) {
21445       {
21446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21447       };
21448     }
21449   }
21450 }
21451
21452
21453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
21454   void * jresult ;
21455   Dali::Texture *arg1 = 0 ;
21456   Dali::Texture *result = 0 ;
21457
21458   arg1 = (Dali::Texture *)jarg1;
21459   if (!arg1) {
21460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21461     return 0;
21462   }
21463   {
21464     try {
21465       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
21466     } catch (std::out_of_range& e) {
21467       {
21468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21469       };
21470     } catch (std::exception& e) {
21471       {
21472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21473       };
21474     } catch (...) {
21475       {
21476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21477       };
21478     }
21479   }
21480   jresult = (void *)result;
21481   return jresult;
21482 }
21483
21484
21485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
21486   void * jresult ;
21487   Dali::BaseHandle arg1 ;
21488   Dali::BaseHandle *argp1 ;
21489   Dali::Texture result;
21490
21491   argp1 = (Dali::BaseHandle *)jarg1;
21492   if (!argp1) {
21493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21494     return 0;
21495   }
21496   arg1 = *argp1;
21497   {
21498     try {
21499       result = Dali::Texture::DownCast(arg1);
21500     } catch (std::out_of_range& e) {
21501       {
21502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21503       };
21504     } catch (std::exception& e) {
21505       {
21506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21507       };
21508     } catch (...) {
21509       {
21510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21511       };
21512     }
21513   }
21514   jresult = new Dali::Texture((const Dali::Texture &)result);
21515   return jresult;
21516 }
21517
21518
21519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
21520   void * jresult ;
21521   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21522   Dali::Texture *arg2 = 0 ;
21523   Dali::Texture *result = 0 ;
21524
21525   arg1 = (Dali::Texture *)jarg1;
21526   arg2 = (Dali::Texture *)jarg2;
21527   if (!arg2) {
21528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21529     return 0;
21530   }
21531   {
21532     try {
21533       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
21534     } catch (std::out_of_range& e) {
21535       {
21536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21537       };
21538     } catch (std::exception& e) {
21539       {
21540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21541       };
21542     } catch (...) {
21543       {
21544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21545       };
21546     }
21547   }
21548   jresult = (void *)result;
21549   return jresult;
21550 }
21551
21552
21553 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
21554   unsigned int jresult ;
21555   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21556   Dali::PixelData arg2 ;
21557   Dali::PixelData *argp2 ;
21558   bool result;
21559
21560   arg1 = (Dali::Texture *)jarg1;
21561   argp2 = (Dali::PixelData *)jarg2;
21562   if (!argp2) {
21563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21564     return 0;
21565   }
21566   arg2 = *argp2;
21567   {
21568     try {
21569       result = (bool)(arg1)->Upload(arg2);
21570     } catch (std::out_of_range& e) {
21571       {
21572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21573       };
21574     } catch (std::exception& e) {
21575       {
21576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21577       };
21578     } catch (...) {
21579       {
21580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21581       };
21582     }
21583   }
21584   jresult = result;
21585   return jresult;
21586 }
21587
21588
21589 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) {
21590   unsigned int jresult ;
21591   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21592   Dali::PixelData arg2 ;
21593   unsigned int arg3 ;
21594   unsigned int arg4 ;
21595   unsigned int arg5 ;
21596   unsigned int arg6 ;
21597   unsigned int arg7 ;
21598   unsigned int arg8 ;
21599   Dali::PixelData *argp2 ;
21600   bool result;
21601
21602   arg1 = (Dali::Texture *)jarg1;
21603   argp2 = (Dali::PixelData *)jarg2;
21604   if (!argp2) {
21605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21606     return 0;
21607   }
21608   arg2 = *argp2;
21609   arg3 = (unsigned int)jarg3;
21610   arg4 = (unsigned int)jarg4;
21611   arg5 = (unsigned int)jarg5;
21612   arg6 = (unsigned int)jarg6;
21613   arg7 = (unsigned int)jarg7;
21614   arg8 = (unsigned int)jarg8;
21615   {
21616     try {
21617       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
21618     } catch (std::out_of_range& e) {
21619       {
21620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21621       };
21622     } catch (std::exception& e) {
21623       {
21624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21625       };
21626     } catch (...) {
21627       {
21628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21629       };
21630     }
21631   }
21632   jresult = result;
21633   return jresult;
21634 }
21635
21636
21637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
21638   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21639
21640   arg1 = (Dali::Texture *)jarg1;
21641   {
21642     try {
21643       (arg1)->GenerateMipmaps();
21644     } catch (std::out_of_range& e) {
21645       {
21646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21647       };
21648     } catch (std::exception& e) {
21649       {
21650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21651       };
21652     } catch (...) {
21653       {
21654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21655       };
21656     }
21657   }
21658 }
21659
21660
21661 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
21662   unsigned int jresult ;
21663   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21664   unsigned int result;
21665
21666   arg1 = (Dali::Texture *)jarg1;
21667   {
21668     try {
21669       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
21670     } catch (std::out_of_range& e) {
21671       {
21672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21673       };
21674     } catch (std::exception& e) {
21675       {
21676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21677       };
21678     } catch (...) {
21679       {
21680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21681       };
21682     }
21683   }
21684   jresult = result;
21685   return jresult;
21686 }
21687
21688
21689 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
21690   unsigned int jresult ;
21691   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21692   unsigned int result;
21693
21694   arg1 = (Dali::Texture *)jarg1;
21695   {
21696     try {
21697       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
21698     } catch (std::out_of_range& e) {
21699       {
21700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21701       };
21702     } catch (std::exception& e) {
21703       {
21704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21705       };
21706     } catch (...) {
21707       {
21708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21709       };
21710     }
21711   }
21712   jresult = result;
21713   return jresult;
21714 }
21715
21716
21717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_2(void * jarg1) {
21718   void * jresult ;
21719   Dali::Internal::Texture *arg1 = (Dali::Internal::Texture *) 0 ;
21720   Dali::Texture *result = 0 ;
21721
21722   arg1 = (Dali::Internal::Texture *)jarg1;
21723   {
21724     try {
21725       result = (Dali::Texture *)new Dali::Texture(arg1);
21726     } catch (std::out_of_range& e) {
21727       {
21728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21729       };
21730     } catch (std::exception& e) {
21731       {
21732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21733       };
21734     } catch (...) {
21735       {
21736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21737       };
21738     }
21739   }
21740   jresult = (void *)result;
21741   return jresult;
21742 }
21743
21744
21745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
21746   void * jresult ;
21747   Dali::Sampler result;
21748
21749   {
21750     try {
21751       result = Dali::Sampler::New();
21752     } catch (std::out_of_range& e) {
21753       {
21754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21755       };
21756     } catch (std::exception& e) {
21757       {
21758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21759       };
21760     } catch (...) {
21761       {
21762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21763       };
21764     }
21765   }
21766   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21767   return jresult;
21768 }
21769
21770
21771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
21772   void * jresult ;
21773   Dali::Sampler *result = 0 ;
21774
21775   {
21776     try {
21777       result = (Dali::Sampler *)new Dali::Sampler();
21778     } catch (std::out_of_range& e) {
21779       {
21780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21781       };
21782     } catch (std::exception& e) {
21783       {
21784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21785       };
21786     } catch (...) {
21787       {
21788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21789       };
21790     }
21791   }
21792   jresult = (void *)result;
21793   return jresult;
21794 }
21795
21796
21797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
21798   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21799
21800   arg1 = (Dali::Sampler *)jarg1;
21801   {
21802     try {
21803       delete arg1;
21804     } catch (std::out_of_range& e) {
21805       {
21806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21807       };
21808     } catch (std::exception& e) {
21809       {
21810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21811       };
21812     } catch (...) {
21813       {
21814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21815       };
21816     }
21817   }
21818 }
21819
21820
21821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
21822   void * jresult ;
21823   Dali::Sampler *arg1 = 0 ;
21824   Dali::Sampler *result = 0 ;
21825
21826   arg1 = (Dali::Sampler *)jarg1;
21827   if (!arg1) {
21828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21829     return 0;
21830   }
21831   {
21832     try {
21833       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
21834     } catch (std::out_of_range& e) {
21835       {
21836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21837       };
21838     } catch (std::exception& e) {
21839       {
21840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21841       };
21842     } catch (...) {
21843       {
21844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21845       };
21846     }
21847   }
21848   jresult = (void *)result;
21849   return jresult;
21850 }
21851
21852
21853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
21854   void * jresult ;
21855   Dali::BaseHandle arg1 ;
21856   Dali::BaseHandle *argp1 ;
21857   Dali::Sampler result;
21858
21859   argp1 = (Dali::BaseHandle *)jarg1;
21860   if (!argp1) {
21861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21862     return 0;
21863   }
21864   arg1 = *argp1;
21865   {
21866     try {
21867       result = Dali::Sampler::DownCast(arg1);
21868     } catch (std::out_of_range& e) {
21869       {
21870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21871       };
21872     } catch (std::exception& e) {
21873       {
21874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21875       };
21876     } catch (...) {
21877       {
21878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21879       };
21880     }
21881   }
21882   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21883   return jresult;
21884 }
21885
21886
21887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
21888   void * jresult ;
21889   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21890   Dali::Sampler *arg2 = 0 ;
21891   Dali::Sampler *result = 0 ;
21892
21893   arg1 = (Dali::Sampler *)jarg1;
21894   arg2 = (Dali::Sampler *)jarg2;
21895   if (!arg2) {
21896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21897     return 0;
21898   }
21899   {
21900     try {
21901       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
21902     } catch (std::out_of_range& e) {
21903       {
21904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21905       };
21906     } catch (std::exception& e) {
21907       {
21908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21909       };
21910     } catch (...) {
21911       {
21912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21913       };
21914     }
21915   }
21916   jresult = (void *)result;
21917   return jresult;
21918 }
21919
21920
21921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
21922   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21923   Dali::FilterMode::Type arg2 ;
21924   Dali::FilterMode::Type arg3 ;
21925
21926   arg1 = (Dali::Sampler *)jarg1;
21927   arg2 = (Dali::FilterMode::Type)jarg2;
21928   arg3 = (Dali::FilterMode::Type)jarg3;
21929   {
21930     try {
21931       (arg1)->SetFilterMode(arg2,arg3);
21932     } catch (std::out_of_range& e) {
21933       {
21934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21935       };
21936     } catch (std::exception& e) {
21937       {
21938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21939       };
21940     } catch (...) {
21941       {
21942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21943       };
21944     }
21945   }
21946 }
21947
21948
21949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
21950   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21951   Dali::WrapMode::Type arg2 ;
21952   Dali::WrapMode::Type arg3 ;
21953
21954   arg1 = (Dali::Sampler *)jarg1;
21955   arg2 = (Dali::WrapMode::Type)jarg2;
21956   arg3 = (Dali::WrapMode::Type)jarg3;
21957   {
21958     try {
21959       (arg1)->SetWrapMode(arg2,arg3);
21960     } catch (std::out_of_range& e) {
21961       {
21962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21963       };
21964     } catch (std::exception& e) {
21965       {
21966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21967       };
21968     } catch (...) {
21969       {
21970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21971       };
21972     }
21973   }
21974 }
21975
21976
21977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
21978   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21979   Dali::WrapMode::Type arg2 ;
21980   Dali::WrapMode::Type arg3 ;
21981   Dali::WrapMode::Type arg4 ;
21982
21983   arg1 = (Dali::Sampler *)jarg1;
21984   arg2 = (Dali::WrapMode::Type)jarg2;
21985   arg3 = (Dali::WrapMode::Type)jarg3;
21986   arg4 = (Dali::WrapMode::Type)jarg4;
21987   {
21988     try {
21989       (arg1)->SetWrapMode(arg2,arg3,arg4);
21990     } catch (std::out_of_range& e) {
21991       {
21992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21993       };
21994     } catch (std::exception& e) {
21995       {
21996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21997       };
21998     } catch (...) {
21999       {
22000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22001       };
22002     }
22003   }
22004 }
22005
22006
22007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
22008   void * jresult ;
22009   Dali::TextureSet result;
22010
22011   {
22012     try {
22013       result = Dali::TextureSet::New();
22014     } catch (std::out_of_range& e) {
22015       {
22016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22017       };
22018     } catch (std::exception& e) {
22019       {
22020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22021       };
22022     } catch (...) {
22023       {
22024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22025       };
22026     }
22027   }
22028   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22029   return jresult;
22030 }
22031
22032
22033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
22034   void * jresult ;
22035   Dali::TextureSet *result = 0 ;
22036
22037   {
22038     try {
22039       result = (Dali::TextureSet *)new Dali::TextureSet();
22040     } catch (std::out_of_range& e) {
22041       {
22042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22043       };
22044     } catch (std::exception& e) {
22045       {
22046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22047       };
22048     } catch (...) {
22049       {
22050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22051       };
22052     }
22053   }
22054   jresult = (void *)result;
22055   return jresult;
22056 }
22057
22058
22059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
22060   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22061
22062   arg1 = (Dali::TextureSet *)jarg1;
22063   {
22064     try {
22065       delete arg1;
22066     } catch (std::out_of_range& e) {
22067       {
22068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22069       };
22070     } catch (std::exception& e) {
22071       {
22072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22073       };
22074     } catch (...) {
22075       {
22076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22077       };
22078     }
22079   }
22080 }
22081
22082
22083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
22084   void * jresult ;
22085   Dali::TextureSet *arg1 = 0 ;
22086   Dali::TextureSet *result = 0 ;
22087
22088   arg1 = (Dali::TextureSet *)jarg1;
22089   if (!arg1) {
22090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22091     return 0;
22092   }
22093   {
22094     try {
22095       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
22096     } catch (std::out_of_range& e) {
22097       {
22098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22099       };
22100     } catch (std::exception& e) {
22101       {
22102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22103       };
22104     } catch (...) {
22105       {
22106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22107       };
22108     }
22109   }
22110   jresult = (void *)result;
22111   return jresult;
22112 }
22113
22114
22115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
22116   void * jresult ;
22117   Dali::BaseHandle arg1 ;
22118   Dali::BaseHandle *argp1 ;
22119   Dali::TextureSet result;
22120
22121   argp1 = (Dali::BaseHandle *)jarg1;
22122   if (!argp1) {
22123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22124     return 0;
22125   }
22126   arg1 = *argp1;
22127   {
22128     try {
22129       result = Dali::TextureSet::DownCast(arg1);
22130     } catch (std::out_of_range& e) {
22131       {
22132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22133       };
22134     } catch (std::exception& e) {
22135       {
22136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22137       };
22138     } catch (...) {
22139       {
22140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22141       };
22142     }
22143   }
22144   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22145   return jresult;
22146 }
22147
22148
22149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
22150   void * jresult ;
22151   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22152   Dali::TextureSet *arg2 = 0 ;
22153   Dali::TextureSet *result = 0 ;
22154
22155   arg1 = (Dali::TextureSet *)jarg1;
22156   arg2 = (Dali::TextureSet *)jarg2;
22157   if (!arg2) {
22158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22159     return 0;
22160   }
22161   {
22162     try {
22163       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
22164     } catch (std::out_of_range& e) {
22165       {
22166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22167       };
22168     } catch (std::exception& e) {
22169       {
22170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22171       };
22172     } catch (...) {
22173       {
22174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22175       };
22176     }
22177   }
22178   jresult = (void *)result;
22179   return jresult;
22180 }
22181
22182
22183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
22184   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22185   size_t arg2 ;
22186   Dali::Texture arg3 ;
22187   Dali::Texture *argp3 ;
22188
22189   arg1 = (Dali::TextureSet *)jarg1;
22190   arg2 = (size_t)jarg2;
22191   argp3 = (Dali::Texture *)jarg3;
22192   if (!argp3) {
22193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
22194     return ;
22195   }
22196   arg3 = *argp3;
22197   {
22198     try {
22199       (arg1)->SetTexture(arg2,arg3);
22200     } catch (std::out_of_range& e) {
22201       {
22202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22203       };
22204     } catch (std::exception& e) {
22205       {
22206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22207       };
22208     } catch (...) {
22209       {
22210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22211       };
22212     }
22213   }
22214 }
22215
22216
22217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
22218   void * jresult ;
22219   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22220   size_t arg2 ;
22221   Dali::Texture result;
22222
22223   arg1 = (Dali::TextureSet *)jarg1;
22224   arg2 = (size_t)jarg2;
22225   {
22226     try {
22227       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
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::Texture((const Dali::Texture &)result);
22243   return jresult;
22244 }
22245
22246
22247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
22248   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22249   size_t arg2 ;
22250   Dali::Sampler arg3 ;
22251   Dali::Sampler *argp3 ;
22252
22253   arg1 = (Dali::TextureSet *)jarg1;
22254   arg2 = (size_t)jarg2;
22255   argp3 = (Dali::Sampler *)jarg3;
22256   if (!argp3) {
22257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
22258     return ;
22259   }
22260   arg3 = *argp3;
22261   {
22262     try {
22263       (arg1)->SetSampler(arg2,arg3);
22264     } catch (std::out_of_range& e) {
22265       {
22266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22267       };
22268     } catch (std::exception& e) {
22269       {
22270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22271       };
22272     } catch (...) {
22273       {
22274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22275       };
22276     }
22277   }
22278 }
22279
22280
22281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
22282   void * jresult ;
22283   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22284   size_t arg2 ;
22285   Dali::Sampler result;
22286
22287   arg1 = (Dali::TextureSet *)jarg1;
22288   arg2 = (size_t)jarg2;
22289   {
22290     try {
22291       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
22292     } catch (std::out_of_range& e) {
22293       {
22294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22295       };
22296     } catch (std::exception& e) {
22297       {
22298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22299       };
22300     } catch (...) {
22301       {
22302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22303       };
22304     }
22305   }
22306   jresult = new Dali::Sampler((const Dali::Sampler &)result);
22307   return jresult;
22308 }
22309
22310
22311 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
22312   unsigned long jresult ;
22313   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22314   size_t result;
22315
22316   arg1 = (Dali::TextureSet *)jarg1;
22317   {
22318     try {
22319       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
22320     } catch (std::out_of_range& e) {
22321       {
22322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22323       };
22324     } catch (std::exception& e) {
22325       {
22326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22327       };
22328     } catch (...) {
22329       {
22330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22331       };
22332     }
22333   }
22334   jresult = (unsigned long)result;
22335   return jresult;
22336 }
22337
22338
22339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
22340   void * jresult ;
22341   Dali::Property::Map *arg1 = 0 ;
22342   Dali::PropertyBuffer result;
22343
22344   arg1 = (Dali::Property::Map *)jarg1;
22345   if (!arg1) {
22346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
22347     return 0;
22348   }
22349   {
22350     try {
22351       result = Dali::PropertyBuffer::New(*arg1);
22352     } catch (std::out_of_range& e) {
22353       {
22354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22355       };
22356     } catch (std::exception& e) {
22357       {
22358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22359       };
22360     } catch (...) {
22361       {
22362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22363       };
22364     }
22365   }
22366   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22367   return jresult;
22368 }
22369
22370
22371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
22372   void * jresult ;
22373   Dali::PropertyBuffer *result = 0 ;
22374
22375   {
22376     try {
22377       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
22378     } catch (std::out_of_range& e) {
22379       {
22380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22381       };
22382     } catch (std::exception& e) {
22383       {
22384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22385       };
22386     } catch (...) {
22387       {
22388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22389       };
22390     }
22391   }
22392   jresult = (void *)result;
22393   return jresult;
22394 }
22395
22396
22397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
22398   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22399
22400   arg1 = (Dali::PropertyBuffer *)jarg1;
22401   {
22402     try {
22403       delete arg1;
22404     } catch (std::out_of_range& e) {
22405       {
22406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22407       };
22408     } catch (std::exception& e) {
22409       {
22410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22411       };
22412     } catch (...) {
22413       {
22414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22415       };
22416     }
22417   }
22418 }
22419
22420
22421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
22422   void * jresult ;
22423   Dali::PropertyBuffer *arg1 = 0 ;
22424   Dali::PropertyBuffer *result = 0 ;
22425
22426   arg1 = (Dali::PropertyBuffer *)jarg1;
22427   if (!arg1) {
22428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22429     return 0;
22430   }
22431   {
22432     try {
22433       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
22434     } catch (std::out_of_range& e) {
22435       {
22436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22437       };
22438     } catch (std::exception& e) {
22439       {
22440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22441       };
22442     } catch (...) {
22443       {
22444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22445       };
22446     }
22447   }
22448   jresult = (void *)result;
22449   return jresult;
22450 }
22451
22452
22453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
22454   void * jresult ;
22455   Dali::BaseHandle arg1 ;
22456   Dali::BaseHandle *argp1 ;
22457   Dali::PropertyBuffer result;
22458
22459   argp1 = (Dali::BaseHandle *)jarg1;
22460   if (!argp1) {
22461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22462     return 0;
22463   }
22464   arg1 = *argp1;
22465   {
22466     try {
22467       result = Dali::PropertyBuffer::DownCast(arg1);
22468     } catch (std::out_of_range& e) {
22469       {
22470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22471       };
22472     } catch (std::exception& e) {
22473       {
22474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22475       };
22476     } catch (...) {
22477       {
22478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22479       };
22480     }
22481   }
22482   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22483   return jresult;
22484 }
22485
22486
22487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
22488   void * jresult ;
22489   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22490   Dali::PropertyBuffer *arg2 = 0 ;
22491   Dali::PropertyBuffer *result = 0 ;
22492
22493   arg1 = (Dali::PropertyBuffer *)jarg1;
22494   arg2 = (Dali::PropertyBuffer *)jarg2;
22495   if (!arg2) {
22496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22497     return 0;
22498   }
22499   {
22500     try {
22501       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
22502     } catch (std::out_of_range& e) {
22503       {
22504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22505       };
22506     } catch (std::exception& e) {
22507       {
22508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22509       };
22510     } catch (...) {
22511       {
22512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22513       };
22514     }
22515   }
22516   jresult = (void *)result;
22517   return jresult;
22518 }
22519
22520
22521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
22522   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22523   void *arg2 = (void *) 0 ;
22524   std::size_t arg3 ;
22525
22526   arg1 = (Dali::PropertyBuffer *)jarg1;
22527   arg2 = jarg2;
22528   arg3 = (std::size_t)jarg3;
22529   {
22530     try {
22531       (arg1)->SetData((void const *)arg2,arg3);
22532     } catch (std::out_of_range& e) {
22533       {
22534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22535       };
22536     } catch (std::exception& e) {
22537       {
22538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22539       };
22540     } catch (...) {
22541       {
22542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22543       };
22544     }
22545   }
22546 }
22547
22548
22549 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
22550   unsigned long jresult ;
22551   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22552   std::size_t result;
22553
22554   arg1 = (Dali::PropertyBuffer *)jarg1;
22555   {
22556     try {
22557       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
22558     } catch (std::out_of_range& e) {
22559       {
22560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22561       };
22562     } catch (std::exception& e) {
22563       {
22564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22565       };
22566     } catch (...) {
22567       {
22568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22569       };
22570     }
22571   }
22572   jresult = (unsigned long)result;
22573   return jresult;
22574 }
22575
22576
22577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
22578   void * jresult ;
22579   Dali::Geometry result;
22580
22581   {
22582     try {
22583       result = Dali::Geometry::New();
22584     } catch (std::out_of_range& e) {
22585       {
22586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22587       };
22588     } catch (std::exception& e) {
22589       {
22590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22591       };
22592     } catch (...) {
22593       {
22594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22595       };
22596     }
22597   }
22598   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22599   return jresult;
22600 }
22601
22602
22603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
22604   void * jresult ;
22605   Dali::Geometry *result = 0 ;
22606
22607   {
22608     try {
22609       result = (Dali::Geometry *)new Dali::Geometry();
22610     } catch (std::out_of_range& e) {
22611       {
22612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22613       };
22614     } catch (std::exception& e) {
22615       {
22616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22617       };
22618     } catch (...) {
22619       {
22620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22621       };
22622     }
22623   }
22624   jresult = (void *)result;
22625   return jresult;
22626 }
22627
22628
22629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
22630   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22631
22632   arg1 = (Dali::Geometry *)jarg1;
22633   {
22634     try {
22635       delete arg1;
22636     } catch (std::out_of_range& e) {
22637       {
22638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22639       };
22640     } catch (std::exception& e) {
22641       {
22642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22643       };
22644     } catch (...) {
22645       {
22646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22647       };
22648     }
22649   }
22650 }
22651
22652
22653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
22654   void * jresult ;
22655   Dali::Geometry *arg1 = 0 ;
22656   Dali::Geometry *result = 0 ;
22657
22658   arg1 = (Dali::Geometry *)jarg1;
22659   if (!arg1) {
22660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22661     return 0;
22662   }
22663   {
22664     try {
22665       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
22666     } catch (std::out_of_range& e) {
22667       {
22668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22669       };
22670     } catch (std::exception& e) {
22671       {
22672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22673       };
22674     } catch (...) {
22675       {
22676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22677       };
22678     }
22679   }
22680   jresult = (void *)result;
22681   return jresult;
22682 }
22683
22684
22685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
22686   void * jresult ;
22687   Dali::BaseHandle arg1 ;
22688   Dali::BaseHandle *argp1 ;
22689   Dali::Geometry result;
22690
22691   argp1 = (Dali::BaseHandle *)jarg1;
22692   if (!argp1) {
22693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22694     return 0;
22695   }
22696   arg1 = *argp1;
22697   {
22698     try {
22699       result = Dali::Geometry::DownCast(arg1);
22700     } catch (std::out_of_range& e) {
22701       {
22702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22703       };
22704     } catch (std::exception& e) {
22705       {
22706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22707       };
22708     } catch (...) {
22709       {
22710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22711       };
22712     }
22713   }
22714   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22715   return jresult;
22716 }
22717
22718
22719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
22720   void * jresult ;
22721   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22722   Dali::Geometry *arg2 = 0 ;
22723   Dali::Geometry *result = 0 ;
22724
22725   arg1 = (Dali::Geometry *)jarg1;
22726   arg2 = (Dali::Geometry *)jarg2;
22727   if (!arg2) {
22728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22729     return 0;
22730   }
22731   {
22732     try {
22733       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
22734     } catch (std::out_of_range& e) {
22735       {
22736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22737       };
22738     } catch (std::exception& e) {
22739       {
22740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22741       };
22742     } catch (...) {
22743       {
22744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22745       };
22746     }
22747   }
22748   jresult = (void *)result;
22749   return jresult;
22750 }
22751
22752
22753 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
22754   unsigned long jresult ;
22755   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22756   Dali::PropertyBuffer *arg2 = 0 ;
22757   std::size_t result;
22758
22759   arg1 = (Dali::Geometry *)jarg1;
22760   arg2 = (Dali::PropertyBuffer *)jarg2;
22761   if (!arg2) {
22762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
22763     return 0;
22764   }
22765   {
22766     try {
22767       result = (arg1)->AddVertexBuffer(*arg2);
22768     } catch (std::out_of_range& e) {
22769       {
22770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22771       };
22772     } catch (std::exception& e) {
22773       {
22774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22775       };
22776     } catch (...) {
22777       {
22778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22779       };
22780     }
22781   }
22782   jresult = (unsigned long)result;
22783   return jresult;
22784 }
22785
22786
22787 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
22788   unsigned long jresult ;
22789   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22790   std::size_t result;
22791
22792   arg1 = (Dali::Geometry *)jarg1;
22793   {
22794     try {
22795       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
22796     } catch (std::out_of_range& e) {
22797       {
22798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22799       };
22800     } catch (std::exception& e) {
22801       {
22802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22803       };
22804     } catch (...) {
22805       {
22806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22807       };
22808     }
22809   }
22810   jresult = (unsigned long)result;
22811   return jresult;
22812 }
22813
22814
22815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
22816   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22817   std::size_t arg2 ;
22818
22819   arg1 = (Dali::Geometry *)jarg1;
22820   arg2 = (std::size_t)jarg2;
22821   {
22822     try {
22823       (arg1)->RemoveVertexBuffer(arg2);
22824     } catch (std::out_of_range& e) {
22825       {
22826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22827       };
22828     } catch (std::exception& e) {
22829       {
22830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22831       };
22832     } catch (...) {
22833       {
22834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22835       };
22836     }
22837   }
22838 }
22839
22840
22841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
22842   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22843   unsigned short *arg2 = (unsigned short *) 0 ;
22844   size_t arg3 ;
22845
22846   arg1 = (Dali::Geometry *)jarg1;
22847   arg2 = jarg2;
22848   arg3 = (size_t)jarg3;
22849   {
22850     try {
22851       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
22852     } catch (std::out_of_range& e) {
22853       {
22854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22855       };
22856     } catch (std::exception& e) {
22857       {
22858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22859       };
22860     } catch (...) {
22861       {
22862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22863       };
22864     }
22865   }
22866
22867
22868 }
22869
22870
22871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
22872   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22873   Dali::Geometry::Type arg2 ;
22874
22875   arg1 = (Dali::Geometry *)jarg1;
22876   arg2 = (Dali::Geometry::Type)jarg2;
22877   {
22878     try {
22879       (arg1)->SetType(arg2);
22880     } catch (std::out_of_range& e) {
22881       {
22882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22883       };
22884     } catch (std::exception& e) {
22885       {
22886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22887       };
22888     } catch (...) {
22889       {
22890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22891       };
22892     }
22893   }
22894 }
22895
22896
22897 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
22898   int jresult ;
22899   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22900   Dali::Geometry::Type result;
22901
22902   arg1 = (Dali::Geometry *)jarg1;
22903   {
22904     try {
22905       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
22906     } catch (std::out_of_range& e) {
22907       {
22908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22909       };
22910     } catch (std::exception& e) {
22911       {
22912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22913       };
22914     } catch (...) {
22915       {
22916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22917       };
22918     }
22919   }
22920   jresult = (int)result;
22921   return jresult;
22922 }
22923
22924
22925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
22926   void * jresult ;
22927   Dali::Shader::Hint *result = 0 ;
22928
22929   {
22930     try {
22931       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
22932     } catch (std::out_of_range& e) {
22933       {
22934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22935       };
22936     } catch (std::exception& e) {
22937       {
22938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22939       };
22940     } catch (...) {
22941       {
22942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22943       };
22944     }
22945   }
22946   jresult = (void *)result;
22947   return jresult;
22948 }
22949
22950
22951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
22952   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
22953
22954   arg1 = (Dali::Shader::Hint *)jarg1;
22955   {
22956     try {
22957       delete arg1;
22958     } catch (std::out_of_range& e) {
22959       {
22960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22961       };
22962     } catch (std::exception& e) {
22963       {
22964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22965       };
22966     } catch (...) {
22967       {
22968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22969       };
22970     }
22971   }
22972 }
22973
22974
22975 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
22976   int jresult ;
22977   int result;
22978
22979   result = (int)Dali::Shader::Property::PROGRAM;
22980   jresult = (int)result;
22981   return jresult;
22982 }
22983
22984
22985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
22986   void * jresult ;
22987   Dali::Shader::Property *result = 0 ;
22988
22989   {
22990     try {
22991       result = (Dali::Shader::Property *)new Dali::Shader::Property();
22992     } catch (std::out_of_range& e) {
22993       {
22994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22995       };
22996     } catch (std::exception& e) {
22997       {
22998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22999       };
23000     } catch (...) {
23001       {
23002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23003       };
23004     }
23005   }
23006   jresult = (void *)result;
23007   return jresult;
23008 }
23009
23010
23011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
23012   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
23013
23014   arg1 = (Dali::Shader::Property *)jarg1;
23015   {
23016     try {
23017       delete arg1;
23018     } catch (std::out_of_range& e) {
23019       {
23020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23021       };
23022     } catch (std::exception& e) {
23023       {
23024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23025       };
23026     } catch (...) {
23027       {
23028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23029       };
23030     }
23031   }
23032 }
23033
23034
23035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
23036   void * jresult ;
23037   std::string *arg1 = 0 ;
23038   std::string *arg2 = 0 ;
23039   Dali::Shader::Hint::Value arg3 ;
23040   Dali::Shader result;
23041
23042   if (!jarg1) {
23043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23044     return 0;
23045   }
23046   std::string arg1_str(jarg1);
23047   arg1 = &arg1_str;
23048   if (!jarg2) {
23049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23050     return 0;
23051   }
23052   std::string arg2_str(jarg2);
23053   arg2 = &arg2_str;
23054   arg3 = (Dali::Shader::Hint::Value)jarg3;
23055   {
23056     try {
23057       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
23058     } catch (std::out_of_range& e) {
23059       {
23060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23061       };
23062     } catch (std::exception& e) {
23063       {
23064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23065       };
23066     } catch (...) {
23067       {
23068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23069       };
23070     }
23071   }
23072   jresult = new Dali::Shader((const Dali::Shader &)result);
23073
23074   //argout typemap for const std::string&
23075
23076
23077   //argout typemap for const std::string&
23078
23079   return jresult;
23080 }
23081
23082
23083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
23084   void * jresult ;
23085   std::string *arg1 = 0 ;
23086   std::string *arg2 = 0 ;
23087   Dali::Shader result;
23088
23089   if (!jarg1) {
23090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23091     return 0;
23092   }
23093   std::string arg1_str(jarg1);
23094   arg1 = &arg1_str;
23095   if (!jarg2) {
23096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23097     return 0;
23098   }
23099   std::string arg2_str(jarg2);
23100   arg2 = &arg2_str;
23101   {
23102     try {
23103       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
23104     } catch (std::out_of_range& e) {
23105       {
23106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23107       };
23108     } catch (std::exception& e) {
23109       {
23110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23111       };
23112     } catch (...) {
23113       {
23114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23115       };
23116     }
23117   }
23118   jresult = new Dali::Shader((const Dali::Shader &)result);
23119
23120   //argout typemap for const std::string&
23121
23122
23123   //argout typemap for const std::string&
23124
23125   return jresult;
23126 }
23127
23128
23129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
23130   void * jresult ;
23131   Dali::Shader *result = 0 ;
23132
23133   {
23134     try {
23135       result = (Dali::Shader *)new Dali::Shader();
23136     } catch (std::out_of_range& e) {
23137       {
23138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23139       };
23140     } catch (std::exception& e) {
23141       {
23142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23143       };
23144     } catch (...) {
23145       {
23146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23147       };
23148     }
23149   }
23150   jresult = (void *)result;
23151   return jresult;
23152 }
23153
23154
23155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
23156   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23157
23158   arg1 = (Dali::Shader *)jarg1;
23159   {
23160     try {
23161       delete arg1;
23162     } catch (std::out_of_range& e) {
23163       {
23164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23165       };
23166     } catch (std::exception& e) {
23167       {
23168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23169       };
23170     } catch (...) {
23171       {
23172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23173       };
23174     }
23175   }
23176 }
23177
23178
23179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
23180   void * jresult ;
23181   Dali::Shader *arg1 = 0 ;
23182   Dali::Shader *result = 0 ;
23183
23184   arg1 = (Dali::Shader *)jarg1;
23185   if (!arg1) {
23186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23187     return 0;
23188   }
23189   {
23190     try {
23191       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
23192     } catch (std::out_of_range& e) {
23193       {
23194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23195       };
23196     } catch (std::exception& e) {
23197       {
23198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23199       };
23200     } catch (...) {
23201       {
23202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23203       };
23204     }
23205   }
23206   jresult = (void *)result;
23207   return jresult;
23208 }
23209
23210
23211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
23212   void * jresult ;
23213   Dali::BaseHandle arg1 ;
23214   Dali::BaseHandle *argp1 ;
23215   Dali::Shader result;
23216
23217   argp1 = (Dali::BaseHandle *)jarg1;
23218   if (!argp1) {
23219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23220     return 0;
23221   }
23222   arg1 = *argp1;
23223   {
23224     try {
23225       result = Dali::Shader::DownCast(arg1);
23226     } catch (std::out_of_range& e) {
23227       {
23228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23229       };
23230     } catch (std::exception& e) {
23231       {
23232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23233       };
23234     } catch (...) {
23235       {
23236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23237       };
23238     }
23239   }
23240   jresult = new Dali::Shader((const Dali::Shader &)result);
23241   return jresult;
23242 }
23243
23244
23245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
23246   void * jresult ;
23247   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23248   Dali::Shader *arg2 = 0 ;
23249   Dali::Shader *result = 0 ;
23250
23251   arg1 = (Dali::Shader *)jarg1;
23252   arg2 = (Dali::Shader *)jarg2;
23253   if (!arg2) {
23254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23255     return 0;
23256   }
23257   {
23258     try {
23259       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
23260     } catch (std::out_of_range& e) {
23261       {
23262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23263       };
23264     } catch (std::exception& e) {
23265       {
23266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23267       };
23268     } catch (...) {
23269       {
23270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23271       };
23272     }
23273   }
23274   jresult = (void *)result;
23275   return jresult;
23276 }
23277
23278
23279 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
23280   int jresult ;
23281   int result;
23282
23283   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
23284   jresult = (int)result;
23285   return jresult;
23286 }
23287
23288
23289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
23290   int jresult ;
23291   int result;
23292
23293   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
23294   jresult = (int)result;
23295   return jresult;
23296 }
23297
23298
23299 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
23300   int jresult ;
23301   int result;
23302
23303   result = (int)Dali::Renderer::Property::BLEND_MODE;
23304   jresult = (int)result;
23305   return jresult;
23306 }
23307
23308
23309 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
23310   int jresult ;
23311   int result;
23312
23313   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
23314   jresult = (int)result;
23315   return jresult;
23316 }
23317
23318
23319 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
23320   int jresult ;
23321   int result;
23322
23323   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
23324   jresult = (int)result;
23325   return jresult;
23326 }
23327
23328
23329 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
23330   int jresult ;
23331   int result;
23332
23333   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
23334   jresult = (int)result;
23335   return jresult;
23336 }
23337
23338
23339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
23340   int jresult ;
23341   int result;
23342
23343   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
23344   jresult = (int)result;
23345   return jresult;
23346 }
23347
23348
23349 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
23350   int jresult ;
23351   int result;
23352
23353   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
23354   jresult = (int)result;
23355   return jresult;
23356 }
23357
23358
23359 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
23360   int jresult ;
23361   int result;
23362
23363   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
23364   jresult = (int)result;
23365   return jresult;
23366 }
23367
23368
23369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
23370   int jresult ;
23371   int result;
23372
23373   result = (int)Dali::Renderer::Property::BLEND_COLOR;
23374   jresult = (int)result;
23375   return jresult;
23376 }
23377
23378
23379 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
23380   int jresult ;
23381   int result;
23382
23383   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
23384   jresult = (int)result;
23385   return jresult;
23386 }
23387
23388
23389 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
23390   int jresult ;
23391   int result;
23392
23393   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
23394   jresult = (int)result;
23395   return jresult;
23396 }
23397
23398
23399 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
23400   int jresult ;
23401   int result;
23402
23403   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
23404   jresult = (int)result;
23405   return jresult;
23406 }
23407
23408
23409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
23410   int jresult ;
23411   int result;
23412
23413   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
23414   jresult = (int)result;
23415   return jresult;
23416 }
23417
23418
23419 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
23420   int jresult ;
23421   int result;
23422
23423   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
23424   jresult = (int)result;
23425   return jresult;
23426 }
23427
23428
23429 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
23430   int jresult ;
23431   int result;
23432
23433   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
23434   jresult = (int)result;
23435   return jresult;
23436 }
23437
23438
23439 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
23440   int jresult ;
23441   int result;
23442
23443   result = (int)Dali::Renderer::Property::RENDER_MODE;
23444   jresult = (int)result;
23445   return jresult;
23446 }
23447
23448
23449 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
23450   int jresult ;
23451   int result;
23452
23453   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
23454   jresult = (int)result;
23455   return jresult;
23456 }
23457
23458
23459 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
23460   int jresult ;
23461   int result;
23462
23463   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
23464   jresult = (int)result;
23465   return jresult;
23466 }
23467
23468
23469 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
23470   int jresult ;
23471   int result;
23472
23473   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
23474   jresult = (int)result;
23475   return jresult;
23476 }
23477
23478
23479 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
23480   int jresult ;
23481   int result;
23482
23483   result = (int)Dali::Renderer::Property::STENCIL_MASK;
23484   jresult = (int)result;
23485   return jresult;
23486 }
23487
23488
23489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
23490   int jresult ;
23491   int result;
23492
23493   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
23494   jresult = (int)result;
23495   return jresult;
23496 }
23497
23498
23499 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
23500   int jresult ;
23501   int result;
23502
23503   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
23504   jresult = (int)result;
23505   return jresult;
23506 }
23507
23508
23509 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
23510   int jresult ;
23511   int result;
23512
23513   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
23514   jresult = (int)result;
23515   return jresult;
23516 }
23517
23518
23519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
23520   void * jresult ;
23521   Dali::Renderer::Property *result = 0 ;
23522
23523   {
23524     try {
23525       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
23526     } catch (std::out_of_range& e) {
23527       {
23528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23529       };
23530     } catch (std::exception& e) {
23531       {
23532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23533       };
23534     } catch (...) {
23535       {
23536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23537       };
23538     }
23539   }
23540   jresult = (void *)result;
23541   return jresult;
23542 }
23543
23544
23545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
23546   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
23547
23548   arg1 = (Dali::Renderer::Property *)jarg1;
23549   {
23550     try {
23551       delete arg1;
23552     } catch (std::out_of_range& e) {
23553       {
23554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23555       };
23556     } catch (std::exception& e) {
23557       {
23558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23559       };
23560     } catch (...) {
23561       {
23562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23563       };
23564     }
23565   }
23566 }
23567
23568
23569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
23570   void * jresult ;
23571   Dali::Geometry *arg1 = 0 ;
23572   Dali::Shader *arg2 = 0 ;
23573   Dali::Renderer result;
23574
23575   arg1 = (Dali::Geometry *)jarg1;
23576   if (!arg1) {
23577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23578     return 0;
23579   }
23580   arg2 = (Dali::Shader *)jarg2;
23581   if (!arg2) {
23582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23583     return 0;
23584   }
23585   {
23586     try {
23587       result = Dali::Renderer::New(*arg1,*arg2);
23588     } catch (std::out_of_range& e) {
23589       {
23590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23591       };
23592     } catch (std::exception& e) {
23593       {
23594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23595       };
23596     } catch (...) {
23597       {
23598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23599       };
23600     }
23601   }
23602   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23603   return jresult;
23604 }
23605
23606
23607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
23608   void * jresult ;
23609   Dali::Renderer *result = 0 ;
23610
23611   {
23612     try {
23613       result = (Dali::Renderer *)new Dali::Renderer();
23614     } catch (std::out_of_range& e) {
23615       {
23616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23617       };
23618     } catch (std::exception& e) {
23619       {
23620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23621       };
23622     } catch (...) {
23623       {
23624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23625       };
23626     }
23627   }
23628   jresult = (void *)result;
23629   return jresult;
23630 }
23631
23632
23633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
23634   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23635
23636   arg1 = (Dali::Renderer *)jarg1;
23637   {
23638     try {
23639       delete arg1;
23640     } catch (std::out_of_range& e) {
23641       {
23642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23643       };
23644     } catch (std::exception& e) {
23645       {
23646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23647       };
23648     } catch (...) {
23649       {
23650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23651       };
23652     }
23653   }
23654 }
23655
23656
23657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
23658   void * jresult ;
23659   Dali::Renderer *arg1 = 0 ;
23660   Dali::Renderer *result = 0 ;
23661
23662   arg1 = (Dali::Renderer *)jarg1;
23663   if (!arg1) {
23664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23665     return 0;
23666   }
23667   {
23668     try {
23669       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
23670     } catch (std::out_of_range& e) {
23671       {
23672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23673       };
23674     } catch (std::exception& e) {
23675       {
23676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23677       };
23678     } catch (...) {
23679       {
23680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23681       };
23682     }
23683   }
23684   jresult = (void *)result;
23685   return jresult;
23686 }
23687
23688
23689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
23690   void * jresult ;
23691   Dali::BaseHandle arg1 ;
23692   Dali::BaseHandle *argp1 ;
23693   Dali::Renderer result;
23694
23695   argp1 = (Dali::BaseHandle *)jarg1;
23696   if (!argp1) {
23697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23698     return 0;
23699   }
23700   arg1 = *argp1;
23701   {
23702     try {
23703       result = Dali::Renderer::DownCast(arg1);
23704     } catch (std::out_of_range& e) {
23705       {
23706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23707       };
23708     } catch (std::exception& e) {
23709       {
23710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23711       };
23712     } catch (...) {
23713       {
23714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23715       };
23716     }
23717   }
23718   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23719   return jresult;
23720 }
23721
23722
23723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
23724   void * jresult ;
23725   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23726   Dali::Renderer *arg2 = 0 ;
23727   Dali::Renderer *result = 0 ;
23728
23729   arg1 = (Dali::Renderer *)jarg1;
23730   arg2 = (Dali::Renderer *)jarg2;
23731   if (!arg2) {
23732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23733     return 0;
23734   }
23735   {
23736     try {
23737       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
23738     } catch (std::out_of_range& e) {
23739       {
23740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23741       };
23742     } catch (std::exception& e) {
23743       {
23744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23745       };
23746     } catch (...) {
23747       {
23748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23749       };
23750     }
23751   }
23752   jresult = (void *)result;
23753   return jresult;
23754 }
23755
23756
23757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
23758   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23759   Dali::Geometry *arg2 = 0 ;
23760
23761   arg1 = (Dali::Renderer *)jarg1;
23762   arg2 = (Dali::Geometry *)jarg2;
23763   if (!arg2) {
23764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23765     return ;
23766   }
23767   {
23768     try {
23769       (arg1)->SetGeometry(*arg2);
23770     } catch (std::out_of_range& e) {
23771       {
23772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23773       };
23774     } catch (std::exception& e) {
23775       {
23776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23777       };
23778     } catch (...) {
23779       {
23780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23781       };
23782     }
23783   }
23784 }
23785
23786
23787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
23788   void * jresult ;
23789   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23790   Dali::Geometry result;
23791
23792   arg1 = (Dali::Renderer *)jarg1;
23793   {
23794     try {
23795       result = ((Dali::Renderer const *)arg1)->GetGeometry();
23796     } catch (std::out_of_range& e) {
23797       {
23798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23799       };
23800     } catch (std::exception& e) {
23801       {
23802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23803       };
23804     } catch (...) {
23805       {
23806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23807       };
23808     }
23809   }
23810   jresult = new Dali::Geometry((const Dali::Geometry &)result);
23811   return jresult;
23812 }
23813
23814
23815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
23816   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23817   int arg2 ;
23818   int arg3 ;
23819
23820   arg1 = (Dali::Renderer *)jarg1;
23821   arg2 = (int)jarg2;
23822   arg3 = (int)jarg3;
23823   {
23824     try {
23825       (arg1)->SetIndexRange(arg2,arg3);
23826     } catch (std::out_of_range& e) {
23827       {
23828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23829       };
23830     } catch (std::exception& e) {
23831       {
23832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23833       };
23834     } catch (...) {
23835       {
23836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23837       };
23838     }
23839   }
23840 }
23841
23842
23843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
23844   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23845   Dali::TextureSet *arg2 = 0 ;
23846
23847   arg1 = (Dali::Renderer *)jarg1;
23848   arg2 = (Dali::TextureSet *)jarg2;
23849   if (!arg2) {
23850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
23851     return ;
23852   }
23853   {
23854     try {
23855       (arg1)->SetTextures(*arg2);
23856     } catch (std::out_of_range& e) {
23857       {
23858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23859       };
23860     } catch (std::exception& e) {
23861       {
23862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23863       };
23864     } catch (...) {
23865       {
23866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23867       };
23868     }
23869   }
23870 }
23871
23872
23873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
23874   void * jresult ;
23875   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23876   Dali::TextureSet result;
23877
23878   arg1 = (Dali::Renderer *)jarg1;
23879   {
23880     try {
23881       result = ((Dali::Renderer const *)arg1)->GetTextures();
23882     } catch (std::out_of_range& e) {
23883       {
23884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23885       };
23886     } catch (std::exception& e) {
23887       {
23888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23889       };
23890     } catch (...) {
23891       {
23892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23893       };
23894     }
23895   }
23896   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
23897   return jresult;
23898 }
23899
23900
23901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
23902   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23903   Dali::Shader *arg2 = 0 ;
23904
23905   arg1 = (Dali::Renderer *)jarg1;
23906   arg2 = (Dali::Shader *)jarg2;
23907   if (!arg2) {
23908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23909     return ;
23910   }
23911   {
23912     try {
23913       (arg1)->SetShader(*arg2);
23914     } catch (std::out_of_range& e) {
23915       {
23916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23917       };
23918     } catch (std::exception& e) {
23919       {
23920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23921       };
23922     } catch (...) {
23923       {
23924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23925       };
23926     }
23927   }
23928 }
23929
23930
23931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
23932   void * jresult ;
23933   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23934   Dali::Shader result;
23935
23936   arg1 = (Dali::Renderer *)jarg1;
23937   {
23938     try {
23939       result = ((Dali::Renderer const *)arg1)->GetShader();
23940     } catch (std::out_of_range& e) {
23941       {
23942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23943       };
23944     } catch (std::exception& e) {
23945       {
23946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23947       };
23948     } catch (...) {
23949       {
23950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23951       };
23952     }
23953   }
23954   jresult = new Dali::Shader((const Dali::Shader &)result);
23955   return jresult;
23956 }
23957
23958
23959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
23960   void * jresult ;
23961   Dali::FrameBuffer::Attachment *result = 0 ;
23962
23963   {
23964     try {
23965       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
23966     } catch (std::out_of_range& e) {
23967       {
23968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23969       };
23970     } catch (std::exception& e) {
23971       {
23972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23973       };
23974     } catch (...) {
23975       {
23976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23977       };
23978     }
23979   }
23980   jresult = (void *)result;
23981   return jresult;
23982 }
23983
23984
23985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
23986   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
23987
23988   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
23989   {
23990     try {
23991       delete arg1;
23992     } catch (std::out_of_range& e) {
23993       {
23994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23995       };
23996     } catch (std::exception& e) {
23997       {
23998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23999       };
24000     } catch (...) {
24001       {
24002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24003       };
24004     }
24005   }
24006 }
24007
24008
24009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
24010   void * jresult ;
24011   unsigned int arg1 ;
24012   unsigned int arg2 ;
24013   unsigned int arg3 ;
24014   Dali::FrameBuffer result;
24015
24016   arg1 = (unsigned int)jarg1;
24017   arg2 = (unsigned int)jarg2;
24018   arg3 = (unsigned int)jarg3;
24019   {
24020     try {
24021       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
24022     } catch (std::out_of_range& e) {
24023       {
24024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24025       };
24026     } catch (std::exception& e) {
24027       {
24028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24029       };
24030     } catch (...) {
24031       {
24032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24033       };
24034     }
24035   }
24036   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24037   return jresult;
24038 }
24039
24040
24041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
24042   void * jresult ;
24043   Dali::FrameBuffer *result = 0 ;
24044
24045   {
24046     try {
24047       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
24048     } catch (std::out_of_range& e) {
24049       {
24050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24051       };
24052     } catch (std::exception& e) {
24053       {
24054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24055       };
24056     } catch (...) {
24057       {
24058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24059       };
24060     }
24061   }
24062   jresult = (void *)result;
24063   return jresult;
24064 }
24065
24066
24067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
24068   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24069
24070   arg1 = (Dali::FrameBuffer *)jarg1;
24071   {
24072     try {
24073       delete arg1;
24074     } catch (std::out_of_range& e) {
24075       {
24076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24077       };
24078     } catch (std::exception& e) {
24079       {
24080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24081       };
24082     } catch (...) {
24083       {
24084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24085       };
24086     }
24087   }
24088 }
24089
24090
24091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
24092   void * jresult ;
24093   Dali::FrameBuffer *arg1 = 0 ;
24094   Dali::FrameBuffer *result = 0 ;
24095
24096   arg1 = (Dali::FrameBuffer *)jarg1;
24097   if (!arg1) {
24098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24099     return 0;
24100   }
24101   {
24102     try {
24103       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
24104     } catch (std::out_of_range& e) {
24105       {
24106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24107       };
24108     } catch (std::exception& e) {
24109       {
24110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24111       };
24112     } catch (...) {
24113       {
24114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24115       };
24116     }
24117   }
24118   jresult = (void *)result;
24119   return jresult;
24120 }
24121
24122
24123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
24124   void * jresult ;
24125   Dali::BaseHandle arg1 ;
24126   Dali::BaseHandle *argp1 ;
24127   Dali::FrameBuffer result;
24128
24129   argp1 = (Dali::BaseHandle *)jarg1;
24130   if (!argp1) {
24131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24132     return 0;
24133   }
24134   arg1 = *argp1;
24135   {
24136     try {
24137       result = Dali::FrameBuffer::DownCast(arg1);
24138     } catch (std::out_of_range& e) {
24139       {
24140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24141       };
24142     } catch (std::exception& e) {
24143       {
24144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24145       };
24146     } catch (...) {
24147       {
24148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24149       };
24150     }
24151   }
24152   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24153   return jresult;
24154 }
24155
24156
24157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
24158   void * jresult ;
24159   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24160   Dali::FrameBuffer *arg2 = 0 ;
24161   Dali::FrameBuffer *result = 0 ;
24162
24163   arg1 = (Dali::FrameBuffer *)jarg1;
24164   arg2 = (Dali::FrameBuffer *)jarg2;
24165   if (!arg2) {
24166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24167     return 0;
24168   }
24169   {
24170     try {
24171       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
24172     } catch (std::out_of_range& e) {
24173       {
24174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24175       };
24176     } catch (std::exception& e) {
24177       {
24178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24179       };
24180     } catch (...) {
24181       {
24182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24183       };
24184     }
24185   }
24186   jresult = (void *)result;
24187   return jresult;
24188 }
24189
24190
24191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
24192   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24193   Dali::Texture *arg2 = 0 ;
24194
24195   arg1 = (Dali::FrameBuffer *)jarg1;
24196   arg2 = (Dali::Texture *)jarg2;
24197   if (!arg2) {
24198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24199     return ;
24200   }
24201   {
24202     try {
24203       (arg1)->AttachColorTexture(*arg2);
24204     } catch (std::out_of_range& e) {
24205       {
24206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24207       };
24208     } catch (std::exception& e) {
24209       {
24210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24211       };
24212     } catch (...) {
24213       {
24214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24215       };
24216     }
24217   }
24218 }
24219
24220
24221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
24222   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24223   Dali::Texture *arg2 = 0 ;
24224   unsigned int arg3 ;
24225   unsigned int arg4 ;
24226
24227   arg1 = (Dali::FrameBuffer *)jarg1;
24228   arg2 = (Dali::Texture *)jarg2;
24229   if (!arg2) {
24230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24231     return ;
24232   }
24233   arg3 = (unsigned int)jarg3;
24234   arg4 = (unsigned int)jarg4;
24235   {
24236     try {
24237       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
24238     } catch (std::out_of_range& e) {
24239       {
24240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24241       };
24242     } catch (std::exception& e) {
24243       {
24244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24245       };
24246     } catch (...) {
24247       {
24248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24249       };
24250     }
24251   }
24252 }
24253
24254
24255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
24256   void * jresult ;
24257   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24258   Dali::Texture result;
24259
24260   arg1 = (Dali::FrameBuffer *)jarg1;
24261   {
24262     try {
24263       result = (arg1)->GetColorTexture();
24264     } catch (std::out_of_range& e) {
24265       {
24266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24267       };
24268     } catch (std::exception& e) {
24269       {
24270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24271       };
24272     } catch (...) {
24273       {
24274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24275       };
24276     }
24277   }
24278   jresult = new Dali::Texture((const Dali::Texture &)result);
24279   return jresult;
24280 }
24281
24282
24283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
24284   void * jresult ;
24285   Dali::RenderTaskList *result = 0 ;
24286
24287   {
24288     try {
24289       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
24290     } catch (std::out_of_range& e) {
24291       {
24292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24293       };
24294     } catch (std::exception& e) {
24295       {
24296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24297       };
24298     } catch (...) {
24299       {
24300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24301       };
24302     }
24303   }
24304   jresult = (void *)result;
24305   return jresult;
24306 }
24307
24308
24309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
24310   void * jresult ;
24311   Dali::BaseHandle arg1 ;
24312   Dali::BaseHandle *argp1 ;
24313   Dali::RenderTaskList result;
24314
24315   argp1 = (Dali::BaseHandle *)jarg1;
24316   if (!argp1) {
24317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24318     return 0;
24319   }
24320   arg1 = *argp1;
24321   {
24322     try {
24323       result = Dali::RenderTaskList::DownCast(arg1);
24324     } catch (std::out_of_range& e) {
24325       {
24326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24327       };
24328     } catch (std::exception& e) {
24329       {
24330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24331       };
24332     } catch (...) {
24333       {
24334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24335       };
24336     }
24337   }
24338   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
24339   return jresult;
24340 }
24341
24342
24343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
24344   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24345
24346   arg1 = (Dali::RenderTaskList *)jarg1;
24347   {
24348     try {
24349       delete arg1;
24350     } catch (std::out_of_range& e) {
24351       {
24352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24353       };
24354     } catch (std::exception& e) {
24355       {
24356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24357       };
24358     } catch (...) {
24359       {
24360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24361       };
24362     }
24363   }
24364 }
24365
24366
24367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
24368   void * jresult ;
24369   Dali::RenderTaskList *arg1 = 0 ;
24370   Dali::RenderTaskList *result = 0 ;
24371
24372   arg1 = (Dali::RenderTaskList *)jarg1;
24373   if (!arg1) {
24374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24375     return 0;
24376   }
24377   {
24378     try {
24379       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
24380     } catch (std::out_of_range& e) {
24381       {
24382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24383       };
24384     } catch (std::exception& e) {
24385       {
24386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24387       };
24388     } catch (...) {
24389       {
24390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24391       };
24392     }
24393   }
24394   jresult = (void *)result;
24395   return jresult;
24396 }
24397
24398
24399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
24400   void * jresult ;
24401   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24402   Dali::RenderTaskList *arg2 = 0 ;
24403   Dali::RenderTaskList *result = 0 ;
24404
24405   arg1 = (Dali::RenderTaskList *)jarg1;
24406   arg2 = (Dali::RenderTaskList *)jarg2;
24407   if (!arg2) {
24408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24409     return 0;
24410   }
24411   {
24412     try {
24413       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
24414     } catch (std::out_of_range& e) {
24415       {
24416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24417       };
24418     } catch (std::exception& e) {
24419       {
24420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24421       };
24422     } catch (...) {
24423       {
24424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24425       };
24426     }
24427   }
24428   jresult = (void *)result;
24429   return jresult;
24430 }
24431
24432
24433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
24434   void * jresult ;
24435   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24436   Dali::RenderTask result;
24437
24438   arg1 = (Dali::RenderTaskList *)jarg1;
24439   {
24440     try {
24441       result = (arg1)->CreateTask();
24442     } catch (std::out_of_range& e) {
24443       {
24444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24445       };
24446     } catch (std::exception& e) {
24447       {
24448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24449       };
24450     } catch (...) {
24451       {
24452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24453       };
24454     }
24455   }
24456   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24457   return jresult;
24458 }
24459
24460
24461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
24462   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24463   Dali::RenderTask arg2 ;
24464   Dali::RenderTask *argp2 ;
24465
24466   arg1 = (Dali::RenderTaskList *)jarg1;
24467   argp2 = (Dali::RenderTask *)jarg2;
24468   if (!argp2) {
24469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
24470     return ;
24471   }
24472   arg2 = *argp2;
24473   {
24474     try {
24475       (arg1)->RemoveTask(arg2);
24476     } catch (std::out_of_range& e) {
24477       {
24478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24479       };
24480     } catch (std::exception& e) {
24481       {
24482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24483       };
24484     } catch (...) {
24485       {
24486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24487       };
24488     }
24489   }
24490 }
24491
24492
24493 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
24494   unsigned int jresult ;
24495   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24496   unsigned int result;
24497
24498   arg1 = (Dali::RenderTaskList *)jarg1;
24499   {
24500     try {
24501       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
24502     } catch (std::out_of_range& e) {
24503       {
24504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24505       };
24506     } catch (std::exception& e) {
24507       {
24508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24509       };
24510     } catch (...) {
24511       {
24512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24513       };
24514     }
24515   }
24516   jresult = result;
24517   return jresult;
24518 }
24519
24520
24521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
24522   void * jresult ;
24523   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24524   unsigned int arg2 ;
24525   Dali::RenderTask result;
24526
24527   arg1 = (Dali::RenderTaskList *)jarg1;
24528   arg2 = (unsigned int)jarg2;
24529   {
24530     try {
24531       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
24532     } catch (std::out_of_range& e) {
24533       {
24534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24535       };
24536     } catch (std::exception& e) {
24537       {
24538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24539       };
24540     } catch (...) {
24541       {
24542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24543       };
24544     }
24545   }
24546   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24547   return jresult;
24548 }
24549
24550
24551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
24552   int jresult ;
24553   int result;
24554
24555   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
24556   jresult = (int)result;
24557   return jresult;
24558 }
24559
24560
24561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
24562   int jresult ;
24563   int result;
24564
24565   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
24566   jresult = (int)result;
24567   return jresult;
24568 }
24569
24570
24571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
24572   int jresult ;
24573   int result;
24574
24575   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
24576   jresult = (int)result;
24577   return jresult;
24578 }
24579
24580
24581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
24582   int jresult ;
24583   int result;
24584
24585   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
24586   jresult = (int)result;
24587   return jresult;
24588 }
24589
24590
24591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
24592   void * jresult ;
24593   Dali::RenderTask::Property *result = 0 ;
24594
24595   {
24596     try {
24597       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
24598     } catch (std::out_of_range& e) {
24599       {
24600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24601       };
24602     } catch (std::exception& e) {
24603       {
24604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24605       };
24606     } catch (...) {
24607       {
24608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24609       };
24610     }
24611   }
24612   jresult = (void *)result;
24613   return jresult;
24614 }
24615
24616
24617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
24618   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
24619
24620   arg1 = (Dali::RenderTask::Property *)jarg1;
24621   {
24622     try {
24623       delete arg1;
24624     } catch (std::out_of_range& e) {
24625       {
24626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24627       };
24628     } catch (std::exception& e) {
24629       {
24630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24631       };
24632     } catch (...) {
24633       {
24634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24635       };
24636     }
24637   }
24638 }
24639
24640
24641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
24642   void * jresult ;
24643   bool (*result)(Dali::Vector2 &) = 0 ;
24644
24645   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
24646   jresult = (void *)result;
24647   return jresult;
24648 }
24649
24650
24651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
24652   void * jresult ;
24653   bool (*result)(Dali::Vector2 &) = 0 ;
24654
24655   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
24656   jresult = (void *)result;
24657   return jresult;
24658 }
24659
24660
24661 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
24662   unsigned int jresult ;
24663   bool result;
24664
24665   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
24666   jresult = result;
24667   return jresult;
24668 }
24669
24670
24671 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
24672   unsigned int jresult ;
24673   bool result;
24674
24675   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
24676   jresult = result;
24677   return jresult;
24678 }
24679
24680
24681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
24682   void * jresult ;
24683   Dali::Vector4 *result = 0 ;
24684
24685   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
24686   jresult = (void *)result;
24687   return jresult;
24688 }
24689
24690
24691 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
24692   unsigned int jresult ;
24693   bool result;
24694
24695   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
24696   jresult = result;
24697   return jresult;
24698 }
24699
24700
24701 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
24702   unsigned int jresult ;
24703   bool result;
24704
24705   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
24706   jresult = result;
24707   return jresult;
24708 }
24709
24710
24711 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
24712   unsigned int jresult ;
24713   unsigned int result;
24714
24715   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
24716   jresult = result;
24717   return jresult;
24718 }
24719
24720
24721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
24722   void * jresult ;
24723   Dali::RenderTask *result = 0 ;
24724
24725   {
24726     try {
24727       result = (Dali::RenderTask *)new Dali::RenderTask();
24728     } catch (std::out_of_range& e) {
24729       {
24730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24731       };
24732     } catch (std::exception& e) {
24733       {
24734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24735       };
24736     } catch (...) {
24737       {
24738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24739       };
24740     }
24741   }
24742   jresult = (void *)result;
24743   return jresult;
24744 }
24745
24746
24747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
24748   void * jresult ;
24749   Dali::BaseHandle arg1 ;
24750   Dali::BaseHandle *argp1 ;
24751   Dali::RenderTask result;
24752
24753   argp1 = (Dali::BaseHandle *)jarg1;
24754   if (!argp1) {
24755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24756     return 0;
24757   }
24758   arg1 = *argp1;
24759   {
24760     try {
24761       result = Dali::RenderTask::DownCast(arg1);
24762     } catch (std::out_of_range& e) {
24763       {
24764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24765       };
24766     } catch (std::exception& e) {
24767       {
24768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24769       };
24770     } catch (...) {
24771       {
24772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24773       };
24774     }
24775   }
24776   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24777   return jresult;
24778 }
24779
24780
24781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
24782   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24783
24784   arg1 = (Dali::RenderTask *)jarg1;
24785   {
24786     try {
24787       delete arg1;
24788     } catch (std::out_of_range& e) {
24789       {
24790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24791       };
24792     } catch (std::exception& e) {
24793       {
24794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24795       };
24796     } catch (...) {
24797       {
24798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24799       };
24800     }
24801   }
24802 }
24803
24804
24805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
24806   void * jresult ;
24807   Dali::RenderTask *arg1 = 0 ;
24808   Dali::RenderTask *result = 0 ;
24809
24810   arg1 = (Dali::RenderTask *)jarg1;
24811   if (!arg1) {
24812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24813     return 0;
24814   }
24815   {
24816     try {
24817       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
24818     } catch (std::out_of_range& e) {
24819       {
24820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24821       };
24822     } catch (std::exception& e) {
24823       {
24824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24825       };
24826     } catch (...) {
24827       {
24828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24829       };
24830     }
24831   }
24832   jresult = (void *)result;
24833   return jresult;
24834 }
24835
24836
24837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
24838   void * jresult ;
24839   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24840   Dali::RenderTask *arg2 = 0 ;
24841   Dali::RenderTask *result = 0 ;
24842
24843   arg1 = (Dali::RenderTask *)jarg1;
24844   arg2 = (Dali::RenderTask *)jarg2;
24845   if (!arg2) {
24846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24847     return 0;
24848   }
24849   {
24850     try {
24851       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
24852     } catch (std::out_of_range& e) {
24853       {
24854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24855       };
24856     } catch (std::exception& e) {
24857       {
24858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24859       };
24860     } catch (...) {
24861       {
24862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24863       };
24864     }
24865   }
24866   jresult = (void *)result;
24867   return jresult;
24868 }
24869
24870
24871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
24872   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24873   Dali::Actor arg2 ;
24874   Dali::Actor *argp2 ;
24875
24876   arg1 = (Dali::RenderTask *)jarg1;
24877   argp2 = (Dali::Actor *)jarg2;
24878   if (!argp2) {
24879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24880     return ;
24881   }
24882   arg2 = *argp2;
24883   {
24884     try {
24885       (arg1)->SetSourceActor(arg2);
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_RenderTask_GetSourceActor(void * jarg1) {
24904   void * jresult ;
24905   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24906   Dali::Actor result;
24907
24908   arg1 = (Dali::RenderTask *)jarg1;
24909   {
24910     try {
24911       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
24912     } catch (std::out_of_range& e) {
24913       {
24914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24915       };
24916     } catch (std::exception& e) {
24917       {
24918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24919       };
24920     } catch (...) {
24921       {
24922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24923       };
24924     }
24925   }
24926   jresult = new Dali::Actor((const Dali::Actor &)result);
24927   return jresult;
24928 }
24929
24930
24931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
24932   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24933   bool arg2 ;
24934
24935   arg1 = (Dali::RenderTask *)jarg1;
24936   arg2 = jarg2 ? true : false;
24937   {
24938     try {
24939       (arg1)->SetExclusive(arg2);
24940     } catch (std::out_of_range& e) {
24941       {
24942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24943       };
24944     } catch (std::exception& e) {
24945       {
24946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24947       };
24948     } catch (...) {
24949       {
24950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24951       };
24952     }
24953   }
24954 }
24955
24956
24957 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
24958   unsigned int jresult ;
24959   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24960   bool result;
24961
24962   arg1 = (Dali::RenderTask *)jarg1;
24963   {
24964     try {
24965       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
24966     } catch (std::out_of_range& e) {
24967       {
24968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24969       };
24970     } catch (std::exception& e) {
24971       {
24972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24973       };
24974     } catch (...) {
24975       {
24976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24977       };
24978     }
24979   }
24980   jresult = result;
24981   return jresult;
24982 }
24983
24984
24985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
24986   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24987   bool arg2 ;
24988
24989   arg1 = (Dali::RenderTask *)jarg1;
24990   arg2 = jarg2 ? true : false;
24991   {
24992     try {
24993       (arg1)->SetInputEnabled(arg2);
24994     } catch (std::out_of_range& e) {
24995       {
24996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24997       };
24998     } catch (std::exception& e) {
24999       {
25000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25001       };
25002     } catch (...) {
25003       {
25004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25005       };
25006     }
25007   }
25008 }
25009
25010
25011 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
25012   unsigned int jresult ;
25013   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25014   bool result;
25015
25016   arg1 = (Dali::RenderTask *)jarg1;
25017   {
25018     try {
25019       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
25020     } catch (std::out_of_range& e) {
25021       {
25022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25023       };
25024     } catch (std::exception& e) {
25025       {
25026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25027       };
25028     } catch (...) {
25029       {
25030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25031       };
25032     }
25033   }
25034   jresult = result;
25035   return jresult;
25036 }
25037
25038
25039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
25040   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25041   Dali::CameraActor arg2 ;
25042   Dali::CameraActor *argp2 ;
25043
25044   arg1 = (Dali::RenderTask *)jarg1;
25045   argp2 = (Dali::CameraActor *)jarg2;
25046   if (!argp2) {
25047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
25048     return ;
25049   }
25050   arg2 = *argp2;
25051   {
25052     try {
25053       (arg1)->SetCameraActor(arg2);
25054     } catch (std::out_of_range& e) {
25055       {
25056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25057       };
25058     } catch (std::exception& e) {
25059       {
25060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25061       };
25062     } catch (...) {
25063       {
25064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25065       };
25066     }
25067   }
25068 }
25069
25070
25071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
25072   void * jresult ;
25073   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25074   Dali::CameraActor result;
25075
25076   arg1 = (Dali::RenderTask *)jarg1;
25077   {
25078     try {
25079       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
25080     } catch (std::out_of_range& e) {
25081       {
25082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25083       };
25084     } catch (std::exception& e) {
25085       {
25086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25087       };
25088     } catch (...) {
25089       {
25090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25091       };
25092     }
25093   }
25094   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
25095   return jresult;
25096 }
25097
25098
25099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
25100   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25101   Dali::FrameBufferImage arg2 ;
25102   Dali::FrameBufferImage *argp2 ;
25103
25104   arg1 = (Dali::RenderTask *)jarg1;
25105   argp2 = (Dali::FrameBufferImage *)jarg2;
25106   if (!argp2) {
25107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
25108     return ;
25109   }
25110   arg2 = *argp2;
25111   {
25112     try {
25113       (arg1)->SetTargetFrameBuffer(arg2);
25114     } catch (std::out_of_range& e) {
25115       {
25116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25117       };
25118     } catch (std::exception& e) {
25119       {
25120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25121       };
25122     } catch (...) {
25123       {
25124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25125       };
25126     }
25127   }
25128 }
25129
25130
25131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
25132   void * jresult ;
25133   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25134   Dali::FrameBufferImage result;
25135
25136   arg1 = (Dali::RenderTask *)jarg1;
25137   {
25138     try {
25139       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
25140     } catch (std::out_of_range& e) {
25141       {
25142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25143       };
25144     } catch (std::exception& e) {
25145       {
25146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25147       };
25148     } catch (...) {
25149       {
25150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25151       };
25152     }
25153   }
25154   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
25155   return jresult;
25156 }
25157
25158
25159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
25160   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25161   Dali::FrameBuffer arg2 ;
25162   Dali::FrameBuffer *argp2 ;
25163
25164   arg1 = (Dali::RenderTask *)jarg1;
25165   argp2 = (Dali::FrameBuffer *)jarg2;
25166   if (!argp2) {
25167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
25168     return ;
25169   }
25170   arg2 = *argp2;
25171   {
25172     try {
25173       (arg1)->SetFrameBuffer(arg2);
25174     } catch (std::out_of_range& e) {
25175       {
25176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25177       };
25178     } catch (std::exception& e) {
25179       {
25180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25181       };
25182     } catch (...) {
25183       {
25184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25185       };
25186     }
25187   }
25188 }
25189
25190
25191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
25192   void * jresult ;
25193   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25194   Dali::FrameBuffer result;
25195
25196   arg1 = (Dali::RenderTask *)jarg1;
25197   {
25198     try {
25199       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
25200     } catch (std::out_of_range& e) {
25201       {
25202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25203       };
25204     } catch (std::exception& e) {
25205       {
25206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25207       };
25208     } catch (...) {
25209       {
25210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25211       };
25212     }
25213   }
25214   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
25215   return jresult;
25216 }
25217
25218
25219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
25220   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25221   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
25222
25223   arg1 = (Dali::RenderTask *)jarg1;
25224   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
25225   {
25226     try {
25227       (arg1)->SetScreenToFrameBufferFunction(arg2);
25228     } catch (std::out_of_range& e) {
25229       {
25230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25231       };
25232     } catch (std::exception& e) {
25233       {
25234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25235       };
25236     } catch (...) {
25237       {
25238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25239       };
25240     }
25241   }
25242 }
25243
25244
25245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
25246   void * jresult ;
25247   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25248   Dali::RenderTask::ScreenToFrameBufferFunction result;
25249
25250   arg1 = (Dali::RenderTask *)jarg1;
25251   {
25252     try {
25253       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
25254     } catch (std::out_of_range& e) {
25255       {
25256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25257       };
25258     } catch (std::exception& e) {
25259       {
25260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25261       };
25262     } catch (...) {
25263       {
25264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25265       };
25266     }
25267   }
25268   jresult = (void *)result;
25269   return jresult;
25270 }
25271
25272
25273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
25274   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25275   Dali::Actor arg2 ;
25276   Dali::Actor *argp2 ;
25277
25278   arg1 = (Dali::RenderTask *)jarg1;
25279   argp2 = (Dali::Actor *)jarg2;
25280   if (!argp2) {
25281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25282     return ;
25283   }
25284   arg2 = *argp2;
25285   {
25286     try {
25287       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
25288     } catch (std::out_of_range& e) {
25289       {
25290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25291       };
25292     } catch (std::exception& e) {
25293       {
25294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25295       };
25296     } catch (...) {
25297       {
25298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25299       };
25300     }
25301   }
25302 }
25303
25304
25305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
25306   void * jresult ;
25307   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25308   Dali::Actor result;
25309
25310   arg1 = (Dali::RenderTask *)jarg1;
25311   {
25312     try {
25313       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
25314     } catch (std::out_of_range& e) {
25315       {
25316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25317       };
25318     } catch (std::exception& e) {
25319       {
25320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25321       };
25322     } catch (...) {
25323       {
25324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25325       };
25326     }
25327   }
25328   jresult = new Dali::Actor((const Dali::Actor &)result);
25329   return jresult;
25330 }
25331
25332
25333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
25334   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25335   Dali::Vector2 arg2 ;
25336   Dali::Vector2 *argp2 ;
25337
25338   arg1 = (Dali::RenderTask *)jarg1;
25339   argp2 = (Dali::Vector2 *)jarg2;
25340   if (!argp2) {
25341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25342     return ;
25343   }
25344   arg2 = *argp2;
25345   {
25346     try {
25347       (arg1)->SetViewportPosition(arg2);
25348     } catch (std::out_of_range& e) {
25349       {
25350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25351       };
25352     } catch (std::exception& e) {
25353       {
25354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25355       };
25356     } catch (...) {
25357       {
25358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25359       };
25360     }
25361   }
25362 }
25363
25364
25365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
25366   void * jresult ;
25367   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25368   Dali::Vector2 result;
25369
25370   arg1 = (Dali::RenderTask *)jarg1;
25371   {
25372     try {
25373       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
25374     } catch (std::out_of_range& e) {
25375       {
25376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25377       };
25378     } catch (std::exception& e) {
25379       {
25380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25381       };
25382     } catch (...) {
25383       {
25384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25385       };
25386     }
25387   }
25388   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25389   return jresult;
25390 }
25391
25392
25393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
25394   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25395   Dali::Vector2 arg2 ;
25396   Dali::Vector2 *argp2 ;
25397
25398   arg1 = (Dali::RenderTask *)jarg1;
25399   argp2 = (Dali::Vector2 *)jarg2;
25400   if (!argp2) {
25401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25402     return ;
25403   }
25404   arg2 = *argp2;
25405   {
25406     try {
25407       (arg1)->SetViewportSize(arg2);
25408     } catch (std::out_of_range& e) {
25409       {
25410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25411       };
25412     } catch (std::exception& e) {
25413       {
25414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25415       };
25416     } catch (...) {
25417       {
25418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25419       };
25420     }
25421   }
25422 }
25423
25424
25425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
25426   void * jresult ;
25427   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25428   Dali::Vector2 result;
25429
25430   arg1 = (Dali::RenderTask *)jarg1;
25431   {
25432     try {
25433       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
25434     } catch (std::out_of_range& e) {
25435       {
25436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25437       };
25438     } catch (std::exception& e) {
25439       {
25440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25441       };
25442     } catch (...) {
25443       {
25444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25445       };
25446     }
25447   }
25448   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25449   return jresult;
25450 }
25451
25452
25453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
25454   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25455   Dali::Viewport arg2 ;
25456   Dali::Viewport *argp2 ;
25457
25458   arg1 = (Dali::RenderTask *)jarg1;
25459   argp2 = (Dali::Viewport *)jarg2;
25460   if (!argp2) {
25461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
25462     return ;
25463   }
25464   arg2 = *argp2;
25465   {
25466     try {
25467       (arg1)->SetViewport(arg2);
25468     } catch (std::out_of_range& e) {
25469       {
25470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25471       };
25472     } catch (std::exception& e) {
25473       {
25474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25475       };
25476     } catch (...) {
25477       {
25478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25479       };
25480     }
25481   }
25482 }
25483
25484
25485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
25486   void * jresult ;
25487   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25488   Dali::Viewport result;
25489
25490   arg1 = (Dali::RenderTask *)jarg1;
25491   {
25492     try {
25493       result = ((Dali::RenderTask const *)arg1)->GetViewport();
25494     } catch (std::out_of_range& e) {
25495       {
25496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25497       };
25498     } catch (std::exception& e) {
25499       {
25500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25501       };
25502     } catch (...) {
25503       {
25504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25505       };
25506     }
25507   }
25508   jresult = new Dali::Viewport((const Dali::Viewport &)result);
25509   return jresult;
25510 }
25511
25512
25513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
25514   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25515   Dali::Vector4 *arg2 = 0 ;
25516
25517   arg1 = (Dali::RenderTask *)jarg1;
25518   arg2 = (Dali::Vector4 *)jarg2;
25519   if (!arg2) {
25520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
25521     return ;
25522   }
25523   {
25524     try {
25525       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
25526     } catch (std::out_of_range& e) {
25527       {
25528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25529       };
25530     } catch (std::exception& e) {
25531       {
25532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25533       };
25534     } catch (...) {
25535       {
25536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25537       };
25538     }
25539   }
25540 }
25541
25542
25543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
25544   void * jresult ;
25545   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25546   Dali::Vector4 result;
25547
25548   arg1 = (Dali::RenderTask *)jarg1;
25549   {
25550     try {
25551       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
25552     } catch (std::out_of_range& e) {
25553       {
25554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25555       };
25556     } catch (std::exception& e) {
25557       {
25558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25559       };
25560     } catch (...) {
25561       {
25562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25563       };
25564     }
25565   }
25566   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
25567   return jresult;
25568 }
25569
25570
25571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
25572   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25573   bool arg2 ;
25574
25575   arg1 = (Dali::RenderTask *)jarg1;
25576   arg2 = jarg2 ? true : false;
25577   {
25578     try {
25579       (arg1)->SetClearEnabled(arg2);
25580     } catch (std::out_of_range& e) {
25581       {
25582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25583       };
25584     } catch (std::exception& e) {
25585       {
25586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25587       };
25588     } catch (...) {
25589       {
25590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25591       };
25592     }
25593   }
25594 }
25595
25596
25597 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
25598   unsigned int jresult ;
25599   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25600   bool result;
25601
25602   arg1 = (Dali::RenderTask *)jarg1;
25603   {
25604     try {
25605       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
25606     } catch (std::out_of_range& e) {
25607       {
25608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25609       };
25610     } catch (std::exception& e) {
25611       {
25612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25613       };
25614     } catch (...) {
25615       {
25616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25617       };
25618     }
25619   }
25620   jresult = result;
25621   return jresult;
25622 }
25623
25624
25625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
25626   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25627   bool arg2 ;
25628
25629   arg1 = (Dali::RenderTask *)jarg1;
25630   arg2 = jarg2 ? true : false;
25631   {
25632     try {
25633       (arg1)->SetCullMode(arg2);
25634     } catch (std::out_of_range& e) {
25635       {
25636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25637       };
25638     } catch (std::exception& e) {
25639       {
25640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25641       };
25642     } catch (...) {
25643       {
25644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25645       };
25646     }
25647   }
25648 }
25649
25650
25651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
25652   unsigned int jresult ;
25653   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25654   bool result;
25655
25656   arg1 = (Dali::RenderTask *)jarg1;
25657   {
25658     try {
25659       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
25660     } catch (std::out_of_range& e) {
25661       {
25662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25663       };
25664     } catch (std::exception& e) {
25665       {
25666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25667       };
25668     } catch (...) {
25669       {
25670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25671       };
25672     }
25673   }
25674   jresult = result;
25675   return jresult;
25676 }
25677
25678
25679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
25680   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25681   unsigned int arg2 ;
25682
25683   arg1 = (Dali::RenderTask *)jarg1;
25684   arg2 = (unsigned int)jarg2;
25685   {
25686     try {
25687       (arg1)->SetRefreshRate(arg2);
25688     } catch (std::out_of_range& e) {
25689       {
25690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25691       };
25692     } catch (std::exception& e) {
25693       {
25694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25695       };
25696     } catch (...) {
25697       {
25698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25699       };
25700     }
25701   }
25702 }
25703
25704
25705 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
25706   unsigned int jresult ;
25707   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25708   unsigned int result;
25709
25710   arg1 = (Dali::RenderTask *)jarg1;
25711   {
25712     try {
25713       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
25714     } catch (std::out_of_range& e) {
25715       {
25716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25717       };
25718     } catch (std::exception& e) {
25719       {
25720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25721       };
25722     } catch (...) {
25723       {
25724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25725       };
25726     }
25727   }
25728   jresult = result;
25729   return jresult;
25730 }
25731
25732
25733 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
25734   unsigned int jresult ;
25735   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25736   Dali::Vector3 *arg2 = 0 ;
25737   float *arg3 = 0 ;
25738   float *arg4 = 0 ;
25739   bool result;
25740
25741   arg1 = (Dali::RenderTask *)jarg1;
25742   arg2 = (Dali::Vector3 *)jarg2;
25743   if (!arg2) {
25744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
25745     return 0;
25746   }
25747   arg3 = (float *)jarg3;
25748   arg4 = (float *)jarg4;
25749   {
25750     try {
25751       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
25752     } catch (std::out_of_range& e) {
25753       {
25754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25755       };
25756     } catch (std::exception& e) {
25757       {
25758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25759       };
25760     } catch (...) {
25761       {
25762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25763       };
25764     }
25765   }
25766   jresult = result;
25767   return jresult;
25768 }
25769
25770
25771 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
25772   unsigned int jresult ;
25773   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25774   Dali::Actor arg2 ;
25775   float arg3 ;
25776   float arg4 ;
25777   float *arg5 = 0 ;
25778   float *arg6 = 0 ;
25779   Dali::Actor *argp2 ;
25780   bool result;
25781
25782   arg1 = (Dali::RenderTask *)jarg1;
25783   argp2 = (Dali::Actor *)jarg2;
25784   if (!argp2) {
25785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25786     return 0;
25787   }
25788   arg2 = *argp2;
25789   arg3 = (float)jarg3;
25790   arg4 = (float)jarg4;
25791   arg5 = (float *)jarg5;
25792   arg6 = (float *)jarg6;
25793   {
25794     try {
25795       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
25796     } catch (std::out_of_range& e) {
25797       {
25798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25799       };
25800     } catch (std::exception& e) {
25801       {
25802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25803       };
25804     } catch (...) {
25805       {
25806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25807       };
25808     }
25809   }
25810   jresult = result;
25811   return jresult;
25812 }
25813
25814
25815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
25816   void * jresult ;
25817   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25818   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
25819
25820   arg1 = (Dali::RenderTask *)jarg1;
25821   {
25822     try {
25823       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
25824     } catch (std::out_of_range& e) {
25825       {
25826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25827       };
25828     } catch (std::exception& e) {
25829       {
25830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25831       };
25832     } catch (...) {
25833       {
25834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25835       };
25836     }
25837   }
25838   jresult = (void *)result;
25839   return jresult;
25840 }
25841
25842
25843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
25844   void * jresult ;
25845   int arg1 ;
25846   Dali::TouchPoint::State arg2 ;
25847   float arg3 ;
25848   float arg4 ;
25849   Dali::TouchPoint *result = 0 ;
25850
25851   arg1 = (int)jarg1;
25852   arg2 = (Dali::TouchPoint::State)jarg2;
25853   arg3 = (float)jarg3;
25854   arg4 = (float)jarg4;
25855   {
25856     try {
25857       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
25858     } catch (std::out_of_range& e) {
25859       {
25860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25861       };
25862     } catch (std::exception& e) {
25863       {
25864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25865       };
25866     } catch (...) {
25867       {
25868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25869       };
25870     }
25871   }
25872   jresult = (void *)result;
25873   return jresult;
25874 }
25875
25876
25877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
25878   void * jresult ;
25879   int arg1 ;
25880   Dali::TouchPoint::State arg2 ;
25881   float arg3 ;
25882   float arg4 ;
25883   float arg5 ;
25884   float arg6 ;
25885   Dali::TouchPoint *result = 0 ;
25886
25887   arg1 = (int)jarg1;
25888   arg2 = (Dali::TouchPoint::State)jarg2;
25889   arg3 = (float)jarg3;
25890   arg4 = (float)jarg4;
25891   arg5 = (float)jarg5;
25892   arg6 = (float)jarg6;
25893   {
25894     try {
25895       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
25896     } catch (std::out_of_range& e) {
25897       {
25898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25899       };
25900     } catch (std::exception& e) {
25901       {
25902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25903       };
25904     } catch (...) {
25905       {
25906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25907       };
25908     }
25909   }
25910   jresult = (void *)result;
25911   return jresult;
25912 }
25913
25914
25915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
25916   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25917
25918   arg1 = (Dali::TouchPoint *)jarg1;
25919   {
25920     try {
25921       delete arg1;
25922     } catch (std::out_of_range& e) {
25923       {
25924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25925       };
25926     } catch (std::exception& e) {
25927       {
25928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25929       };
25930     } catch (...) {
25931       {
25932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25933       };
25934     }
25935   }
25936 }
25937
25938
25939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
25940   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25941   int arg2 ;
25942
25943   arg1 = (Dali::TouchPoint *)jarg1;
25944   arg2 = (int)jarg2;
25945   if (arg1) (arg1)->deviceId = arg2;
25946 }
25947
25948
25949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
25950   int jresult ;
25951   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25952   int result;
25953
25954   arg1 = (Dali::TouchPoint *)jarg1;
25955   result = (int) ((arg1)->deviceId);
25956   jresult = result;
25957   return jresult;
25958 }
25959
25960
25961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
25962   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25963   Dali::TouchPoint::State arg2 ;
25964
25965   arg1 = (Dali::TouchPoint *)jarg1;
25966   arg2 = (Dali::TouchPoint::State)jarg2;
25967   if (arg1) (arg1)->state = arg2;
25968 }
25969
25970
25971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
25972   int jresult ;
25973   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25974   Dali::TouchPoint::State result;
25975
25976   arg1 = (Dali::TouchPoint *)jarg1;
25977   result = (Dali::TouchPoint::State) ((arg1)->state);
25978   jresult = (int)result;
25979   return jresult;
25980 }
25981
25982
25983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
25984   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25985   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
25986
25987   arg1 = (Dali::TouchPoint *)jarg1;
25988   arg2 = (Dali::Actor *)jarg2;
25989   if (arg1) (arg1)->hitActor = *arg2;
25990 }
25991
25992
25993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
25994   void * jresult ;
25995   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25996   Dali::Actor *result = 0 ;
25997
25998   arg1 = (Dali::TouchPoint *)jarg1;
25999   result = (Dali::Actor *)& ((arg1)->hitActor);
26000   jresult = (void *)result;
26001   return jresult;
26002 }
26003
26004
26005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
26006   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26007   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26008
26009   arg1 = (Dali::TouchPoint *)jarg1;
26010   arg2 = (Dali::Vector2 *)jarg2;
26011   if (arg1) (arg1)->local = *arg2;
26012 }
26013
26014
26015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
26016   void * jresult ;
26017   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26018   Dali::Vector2 *result = 0 ;
26019
26020   arg1 = (Dali::TouchPoint *)jarg1;
26021   result = (Dali::Vector2 *)& ((arg1)->local);
26022   jresult = (void *)result;
26023   return jresult;
26024 }
26025
26026
26027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
26028   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26029   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26030
26031   arg1 = (Dali::TouchPoint *)jarg1;
26032   arg2 = (Dali::Vector2 *)jarg2;
26033   if (arg1) (arg1)->screen = *arg2;
26034 }
26035
26036
26037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
26038   void * jresult ;
26039   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26040   Dali::Vector2 *result = 0 ;
26041
26042   arg1 = (Dali::TouchPoint *)jarg1;
26043   result = (Dali::Vector2 *)& ((arg1)->screen);
26044   jresult = (void *)result;
26045   return jresult;
26046 }
26047
26048
26049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
26050   void * jresult ;
26051   Dali::TouchData *result = 0 ;
26052
26053   {
26054     try {
26055       result = (Dali::TouchData *)new Dali::TouchData();
26056     } catch (std::out_of_range& e) {
26057       {
26058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26059       };
26060     } catch (std::exception& e) {
26061       {
26062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26063       };
26064     } catch (...) {
26065       {
26066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26067       };
26068     }
26069   }
26070   jresult = (void *)result;
26071   return jresult;
26072 }
26073
26074
26075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
26076   void * jresult ;
26077   Dali::TouchData *arg1 = 0 ;
26078   Dali::TouchData *result = 0 ;
26079
26080   arg1 = (Dali::TouchData *)jarg1;
26081   if (!arg1) {
26082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26083     return 0;
26084   }
26085   {
26086     try {
26087       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
26088     } catch (std::out_of_range& e) {
26089       {
26090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26091       };
26092     } catch (std::exception& e) {
26093       {
26094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26095       };
26096     } catch (...) {
26097       {
26098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26099       };
26100     }
26101   }
26102   jresult = (void *)result;
26103   return jresult;
26104 }
26105
26106
26107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
26108   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26109
26110   arg1 = (Dali::TouchData *)jarg1;
26111   {
26112     try {
26113       delete arg1;
26114     } catch (std::out_of_range& e) {
26115       {
26116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26117       };
26118     } catch (std::exception& e) {
26119       {
26120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26121       };
26122     } catch (...) {
26123       {
26124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26125       };
26126     }
26127   }
26128 }
26129
26130
26131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
26132   void * jresult ;
26133   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26134   Dali::TouchData *arg2 = 0 ;
26135   Dali::TouchData *result = 0 ;
26136
26137   arg1 = (Dali::TouchData *)jarg1;
26138   arg2 = (Dali::TouchData *)jarg2;
26139   if (!arg2) {
26140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26141     return 0;
26142   }
26143   {
26144     try {
26145       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
26146     } catch (std::out_of_range& e) {
26147       {
26148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26149       };
26150     } catch (std::exception& e) {
26151       {
26152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26153       };
26154     } catch (...) {
26155       {
26156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26157       };
26158     }
26159   }
26160   jresult = (void *)result;
26161   return jresult;
26162 }
26163
26164
26165 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
26166   unsigned long jresult ;
26167   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26168   unsigned long result;
26169
26170   arg1 = (Dali::TouchData *)jarg1;
26171   {
26172     try {
26173       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
26174     } catch (std::out_of_range& e) {
26175       {
26176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26177       };
26178     } catch (std::exception& e) {
26179       {
26180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26181       };
26182     } catch (...) {
26183       {
26184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26185       };
26186     }
26187   }
26188   jresult = (unsigned long)result;
26189   return jresult;
26190 }
26191
26192
26193 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
26194   unsigned long jresult ;
26195   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26196   std::size_t result;
26197
26198   arg1 = (Dali::TouchData *)jarg1;
26199   {
26200     try {
26201       result = ((Dali::TouchData const *)arg1)->GetPointCount();
26202     } catch (std::out_of_range& e) {
26203       {
26204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26205       };
26206     } catch (std::exception& e) {
26207       {
26208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26209       };
26210     } catch (...) {
26211       {
26212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26213       };
26214     }
26215   }
26216   jresult = (unsigned long)result;
26217   return jresult;
26218 }
26219
26220
26221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
26222   int jresult ;
26223   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26224   std::size_t arg2 ;
26225   int32_t result;
26226
26227   arg1 = (Dali::TouchData *)jarg1;
26228   arg2 = (std::size_t)jarg2;
26229   {
26230     try {
26231       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
26232     } catch (std::out_of_range& e) {
26233       {
26234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26235       };
26236     } catch (std::exception& e) {
26237       {
26238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26239       };
26240     } catch (...) {
26241       {
26242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26243       };
26244     }
26245   }
26246   jresult = result;
26247   return jresult;
26248 }
26249
26250
26251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
26252   int jresult ;
26253   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26254   std::size_t arg2 ;
26255   Dali::PointState::Type result;
26256
26257   arg1 = (Dali::TouchData *)jarg1;
26258   arg2 = (std::size_t)jarg2;
26259   {
26260     try {
26261       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
26262     } catch (std::out_of_range& e) {
26263       {
26264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26265       };
26266     } catch (std::exception& e) {
26267       {
26268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26269       };
26270     } catch (...) {
26271       {
26272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26273       };
26274     }
26275   }
26276   jresult = (int)result;
26277   return jresult;
26278 }
26279
26280
26281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
26282   void * jresult ;
26283   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26284   std::size_t arg2 ;
26285   Dali::Actor result;
26286
26287   arg1 = (Dali::TouchData *)jarg1;
26288   arg2 = (std::size_t)jarg2;
26289   {
26290     try {
26291       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
26292     } catch (std::out_of_range& e) {
26293       {
26294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26295       };
26296     } catch (std::exception& e) {
26297       {
26298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26299       };
26300     } catch (...) {
26301       {
26302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26303       };
26304     }
26305   }
26306   jresult = new Dali::Actor((const Dali::Actor &)result);
26307   return jresult;
26308 }
26309
26310
26311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
26312   void * jresult ;
26313   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26314   std::size_t arg2 ;
26315   Dali::Vector2 *result = 0 ;
26316
26317   arg1 = (Dali::TouchData *)jarg1;
26318   arg2 = (std::size_t)jarg2;
26319   {
26320     try {
26321       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
26322     } catch (std::out_of_range& e) {
26323       {
26324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26325       };
26326     } catch (std::exception& e) {
26327       {
26328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26329       };
26330     } catch (...) {
26331       {
26332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26333       };
26334     }
26335   }
26336   jresult = (void *)result;
26337   return jresult;
26338 }
26339
26340
26341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
26342   void * jresult ;
26343   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26344   std::size_t arg2 ;
26345   Dali::Vector2 *result = 0 ;
26346
26347   arg1 = (Dali::TouchData *)jarg1;
26348   arg2 = (std::size_t)jarg2;
26349   {
26350     try {
26351       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
26352     } catch (std::out_of_range& e) {
26353       {
26354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26355       };
26356     } catch (std::exception& e) {
26357       {
26358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26359       };
26360     } catch (...) {
26361       {
26362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26363       };
26364     }
26365   }
26366   jresult = (void *)result;
26367   return jresult;
26368 }
26369
26370
26371 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
26372   float jresult ;
26373   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26374   std::size_t arg2 ;
26375   float result;
26376
26377   arg1 = (Dali::TouchData *)jarg1;
26378   arg2 = (std::size_t)jarg2;
26379   {
26380     try {
26381       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
26382     } catch (std::out_of_range& e) {
26383       {
26384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26385       };
26386     } catch (std::exception& e) {
26387       {
26388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26389       };
26390     } catch (...) {
26391       {
26392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26393       };
26394     }
26395   }
26396   jresult = result;
26397   return jresult;
26398 }
26399
26400
26401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
26402   void * jresult ;
26403   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26404   std::size_t arg2 ;
26405   Dali::Vector2 *result = 0 ;
26406
26407   arg1 = (Dali::TouchData *)jarg1;
26408   arg2 = (std::size_t)jarg2;
26409   {
26410     try {
26411       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
26412     } catch (std::out_of_range& e) {
26413       {
26414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26415       };
26416     } catch (std::exception& e) {
26417       {
26418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26419       };
26420     } catch (...) {
26421       {
26422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26423       };
26424     }
26425   }
26426   jresult = (void *)result;
26427   return jresult;
26428 }
26429
26430
26431 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
26432   float jresult ;
26433   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26434   std::size_t arg2 ;
26435   float result;
26436
26437   arg1 = (Dali::TouchData *)jarg1;
26438   arg2 = (std::size_t)jarg2;
26439   {
26440     try {
26441       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
26442     } catch (std::out_of_range& e) {
26443       {
26444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26445       };
26446     } catch (std::exception& e) {
26447       {
26448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26449       };
26450     } catch (...) {
26451       {
26452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26453       };
26454     }
26455   }
26456   jresult = result;
26457   return jresult;
26458 }
26459
26460
26461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
26462   void * jresult ;
26463   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26464   std::size_t arg2 ;
26465   Dali::Degree result;
26466
26467   arg1 = (Dali::TouchData *)jarg1;
26468   arg2 = (std::size_t)jarg2;
26469   {
26470     try {
26471       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
26472     } catch (std::out_of_range& e) {
26473       {
26474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26475       };
26476     } catch (std::exception& e) {
26477       {
26478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26479       };
26480     } catch (...) {
26481       {
26482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26483       };
26484     }
26485   }
26486   jresult = new Dali::Degree((const Dali::Degree &)result);
26487   return jresult;
26488 }
26489
26490
26491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
26492   void * jresult ;
26493   Dali::GestureDetector *result = 0 ;
26494
26495   {
26496     try {
26497       result = (Dali::GestureDetector *)new Dali::GestureDetector();
26498     } catch (std::out_of_range& e) {
26499       {
26500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26501       };
26502     } catch (std::exception& e) {
26503       {
26504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26505       };
26506     } catch (...) {
26507       {
26508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26509       };
26510     }
26511   }
26512   jresult = (void *)result;
26513   return jresult;
26514 }
26515
26516
26517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
26518   void * jresult ;
26519   Dali::BaseHandle arg1 ;
26520   Dali::BaseHandle *argp1 ;
26521   Dali::GestureDetector result;
26522
26523   argp1 = (Dali::BaseHandle *)jarg1;
26524   if (!argp1) {
26525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26526     return 0;
26527   }
26528   arg1 = *argp1;
26529   {
26530     try {
26531       result = Dali::GestureDetector::DownCast(arg1);
26532     } catch (std::out_of_range& e) {
26533       {
26534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26535       };
26536     } catch (std::exception& e) {
26537       {
26538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26539       };
26540     } catch (...) {
26541       {
26542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26543       };
26544     }
26545   }
26546   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
26547   return jresult;
26548 }
26549
26550
26551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
26552   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26553
26554   arg1 = (Dali::GestureDetector *)jarg1;
26555   {
26556     try {
26557       delete arg1;
26558     } catch (std::out_of_range& e) {
26559       {
26560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26561       };
26562     } catch (std::exception& e) {
26563       {
26564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26565       };
26566     } catch (...) {
26567       {
26568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26569       };
26570     }
26571   }
26572 }
26573
26574
26575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
26576   void * jresult ;
26577   Dali::GestureDetector *arg1 = 0 ;
26578   Dali::GestureDetector *result = 0 ;
26579
26580   arg1 = (Dali::GestureDetector *)jarg1;
26581   if (!arg1) {
26582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26583     return 0;
26584   }
26585   {
26586     try {
26587       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
26588     } catch (std::out_of_range& e) {
26589       {
26590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26591       };
26592     } catch (std::exception& e) {
26593       {
26594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26595       };
26596     } catch (...) {
26597       {
26598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26599       };
26600     }
26601   }
26602   jresult = (void *)result;
26603   return jresult;
26604 }
26605
26606
26607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
26608   void * jresult ;
26609   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26610   Dali::GestureDetector *arg2 = 0 ;
26611   Dali::GestureDetector *result = 0 ;
26612
26613   arg1 = (Dali::GestureDetector *)jarg1;
26614   arg2 = (Dali::GestureDetector *)jarg2;
26615   if (!arg2) {
26616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26617     return 0;
26618   }
26619   {
26620     try {
26621       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
26622     } catch (std::out_of_range& e) {
26623       {
26624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26625       };
26626     } catch (std::exception& e) {
26627       {
26628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26629       };
26630     } catch (...) {
26631       {
26632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26633       };
26634     }
26635   }
26636   jresult = (void *)result;
26637   return jresult;
26638 }
26639
26640
26641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
26642   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26643   Dali::Actor arg2 ;
26644   Dali::Actor *argp2 ;
26645
26646   arg1 = (Dali::GestureDetector *)jarg1;
26647   argp2 = (Dali::Actor *)jarg2;
26648   if (!argp2) {
26649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26650     return ;
26651   }
26652   arg2 = *argp2;
26653   {
26654     try {
26655       (arg1)->Attach(arg2);
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_GestureDetector_Detach(void * jarg1, void * jarg2) {
26674   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26675   Dali::Actor arg2 ;
26676   Dali::Actor *argp2 ;
26677
26678   arg1 = (Dali::GestureDetector *)jarg1;
26679   argp2 = (Dali::Actor *)jarg2;
26680   if (!argp2) {
26681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26682     return ;
26683   }
26684   arg2 = *argp2;
26685   {
26686     try {
26687       (arg1)->Detach(arg2);
26688     } catch (std::out_of_range& e) {
26689       {
26690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26691       };
26692     } catch (std::exception& e) {
26693       {
26694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26695       };
26696     } catch (...) {
26697       {
26698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26699       };
26700     }
26701   }
26702 }
26703
26704
26705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
26706   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26707
26708   arg1 = (Dali::GestureDetector *)jarg1;
26709   {
26710     try {
26711       (arg1)->DetachAll();
26712     } catch (std::out_of_range& e) {
26713       {
26714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26715       };
26716     } catch (std::exception& e) {
26717       {
26718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26719       };
26720     } catch (...) {
26721       {
26722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26723       };
26724     }
26725   }
26726 }
26727
26728
26729 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
26730   unsigned long jresult ;
26731   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26732   size_t result;
26733
26734   arg1 = (Dali::GestureDetector *)jarg1;
26735   {
26736     try {
26737       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
26738     } catch (std::out_of_range& e) {
26739       {
26740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26741       };
26742     } catch (std::exception& e) {
26743       {
26744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26745       };
26746     } catch (...) {
26747       {
26748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26749       };
26750     }
26751   }
26752   jresult = (unsigned long)result;
26753   return jresult;
26754 }
26755
26756
26757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
26758   void * jresult ;
26759   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26760   size_t arg2 ;
26761   Dali::Actor result;
26762
26763   arg1 = (Dali::GestureDetector *)jarg1;
26764   arg2 = (size_t)jarg2;
26765   {
26766     try {
26767       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
26768     } catch (std::out_of_range& e) {
26769       {
26770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26771       };
26772     } catch (std::exception& e) {
26773       {
26774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26775       };
26776     } catch (...) {
26777       {
26778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26779       };
26780     }
26781   }
26782   jresult = new Dali::Actor((const Dali::Actor &)result);
26783   return jresult;
26784 }
26785
26786
26787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
26788   void * jresult ;
26789   Dali::Gesture *arg1 = 0 ;
26790   Dali::Gesture *result = 0 ;
26791
26792   arg1 = (Dali::Gesture *)jarg1;
26793   if (!arg1) {
26794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26795     return 0;
26796   }
26797   {
26798     try {
26799       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
26800     } catch (std::out_of_range& e) {
26801       {
26802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26803       };
26804     } catch (std::exception& e) {
26805       {
26806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26807       };
26808     } catch (...) {
26809       {
26810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26811       };
26812     }
26813   }
26814   jresult = (void *)result;
26815   return jresult;
26816 }
26817
26818
26819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
26820   void * jresult ;
26821   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26822   Dali::Gesture *arg2 = 0 ;
26823   Dali::Gesture *result = 0 ;
26824
26825   arg1 = (Dali::Gesture *)jarg1;
26826   arg2 = (Dali::Gesture *)jarg2;
26827   if (!arg2) {
26828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26829     return 0;
26830   }
26831   {
26832     try {
26833       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
26834     } catch (std::out_of_range& e) {
26835       {
26836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26837       };
26838     } catch (std::exception& e) {
26839       {
26840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26841       };
26842     } catch (...) {
26843       {
26844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26845       };
26846     }
26847   }
26848   jresult = (void *)result;
26849   return jresult;
26850 }
26851
26852
26853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
26854   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26855
26856   arg1 = (Dali::Gesture *)jarg1;
26857   {
26858     try {
26859       delete arg1;
26860     } catch (std::out_of_range& e) {
26861       {
26862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26863       };
26864     } catch (std::exception& e) {
26865       {
26866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26867       };
26868     } catch (...) {
26869       {
26870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26871       };
26872     }
26873   }
26874 }
26875
26876
26877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
26878   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26879   Dali::Gesture::Type arg2 ;
26880
26881   arg1 = (Dali::Gesture *)jarg1;
26882   arg2 = (Dali::Gesture::Type)jarg2;
26883   if (arg1) (arg1)->type = arg2;
26884 }
26885
26886
26887 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
26888   int jresult ;
26889   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26890   Dali::Gesture::Type result;
26891
26892   arg1 = (Dali::Gesture *)jarg1;
26893   result = (Dali::Gesture::Type) ((arg1)->type);
26894   jresult = (int)result;
26895   return jresult;
26896 }
26897
26898
26899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
26900   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26901   Dali::Gesture::State arg2 ;
26902
26903   arg1 = (Dali::Gesture *)jarg1;
26904   arg2 = (Dali::Gesture::State)jarg2;
26905   if (arg1) (arg1)->state = arg2;
26906 }
26907
26908
26909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
26910   int jresult ;
26911   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26912   Dali::Gesture::State result;
26913
26914   arg1 = (Dali::Gesture *)jarg1;
26915   result = (Dali::Gesture::State) ((arg1)->state);
26916   jresult = (int)result;
26917   return jresult;
26918 }
26919
26920
26921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
26922   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26923   unsigned int arg2 ;
26924
26925   arg1 = (Dali::Gesture *)jarg1;
26926   arg2 = (unsigned int)jarg2;
26927   if (arg1) (arg1)->time = arg2;
26928 }
26929
26930
26931 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
26932   unsigned int jresult ;
26933   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26934   unsigned int result;
26935
26936   arg1 = (Dali::Gesture *)jarg1;
26937   result = (unsigned int) ((arg1)->time);
26938   jresult = result;
26939   return jresult;
26940 }
26941
26942
26943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
26944   void * jresult ;
26945   Dali::HoverEvent *result = 0 ;
26946
26947   {
26948     try {
26949       result = (Dali::HoverEvent *)new Dali::HoverEvent();
26950     } catch (std::out_of_range& e) {
26951       {
26952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26953       };
26954     } catch (std::exception& e) {
26955       {
26956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26957       };
26958     } catch (...) {
26959       {
26960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26961       };
26962     }
26963   }
26964   jresult = (void *)result;
26965   return jresult;
26966 }
26967
26968
26969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
26970   void * jresult ;
26971   unsigned long arg1 ;
26972   Dali::HoverEvent *result = 0 ;
26973
26974   arg1 = (unsigned long)jarg1;
26975   {
26976     try {
26977       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
26978     } catch (std::out_of_range& e) {
26979       {
26980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26981       };
26982     } catch (std::exception& e) {
26983       {
26984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26985       };
26986     } catch (...) {
26987       {
26988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26989       };
26990     }
26991   }
26992   jresult = (void *)result;
26993   return jresult;
26994 }
26995
26996
26997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
26998   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
26999
27000   arg1 = (Dali::HoverEvent *)jarg1;
27001   {
27002     try {
27003       delete arg1;
27004     } catch (std::out_of_range& e) {
27005       {
27006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27007       };
27008     } catch (std::exception& e) {
27009       {
27010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27011       };
27012     } catch (...) {
27013       {
27014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27015       };
27016     }
27017   }
27018 }
27019
27020
27021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
27022   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27023   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
27024
27025   arg1 = (Dali::HoverEvent *)jarg1;
27026   arg2 = (Dali::TouchPointContainer *)jarg2;
27027   if (arg1) (arg1)->points = *arg2;
27028 }
27029
27030
27031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
27032   void * jresult ;
27033   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27034   Dali::TouchPointContainer *result = 0 ;
27035
27036   arg1 = (Dali::HoverEvent *)jarg1;
27037   result = (Dali::TouchPointContainer *)& ((arg1)->points);
27038   jresult = (void *)result;
27039   return jresult;
27040 }
27041
27042
27043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
27044   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27045   unsigned long arg2 ;
27046
27047   arg1 = (Dali::HoverEvent *)jarg1;
27048   arg2 = (unsigned long)jarg2;
27049   if (arg1) (arg1)->time = arg2;
27050 }
27051
27052
27053 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
27054   unsigned long jresult ;
27055   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27056   unsigned long result;
27057
27058   arg1 = (Dali::HoverEvent *)jarg1;
27059   result = (unsigned long) ((arg1)->time);
27060   jresult = (unsigned long)result;
27061   return jresult;
27062 }
27063
27064
27065 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
27066   unsigned int jresult ;
27067   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27068   unsigned int result;
27069
27070   arg1 = (Dali::HoverEvent *)jarg1;
27071   {
27072     try {
27073       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
27074     } catch (std::out_of_range& e) {
27075       {
27076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27077       };
27078     } catch (std::exception& e) {
27079       {
27080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27081       };
27082     } catch (...) {
27083       {
27084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27085       };
27086     }
27087   }
27088   jresult = result;
27089   return jresult;
27090 }
27091
27092
27093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
27094   void * jresult ;
27095   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27096   unsigned int arg2 ;
27097   Dali::TouchPoint *result = 0 ;
27098
27099   arg1 = (Dali::HoverEvent *)jarg1;
27100   arg2 = (unsigned int)jarg2;
27101   {
27102     try {
27103       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
27104     } catch (std::out_of_range& e) {
27105       {
27106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27107       };
27108     } catch (std::exception& e) {
27109       {
27110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27111       };
27112     } catch (...) {
27113       {
27114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27115       };
27116     }
27117   }
27118   jresult = (void *)result;
27119   return jresult;
27120 }
27121
27122
27123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
27124   void * jresult ;
27125   Dali::KeyEvent *result = 0 ;
27126
27127   {
27128     try {
27129       result = (Dali::KeyEvent *)new Dali::KeyEvent();
27130     } catch (std::out_of_range& e) {
27131       {
27132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27133       };
27134     } catch (std::exception& e) {
27135       {
27136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27137       };
27138     } catch (...) {
27139       {
27140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27141       };
27142     }
27143   }
27144   jresult = (void *)result;
27145   return jresult;
27146 }
27147
27148
27149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
27150   void * jresult ;
27151   std::string *arg1 = 0 ;
27152   std::string *arg2 = 0 ;
27153   int arg3 ;
27154   int arg4 ;
27155   unsigned long arg5 ;
27156   Dali::KeyEvent::State *arg6 = 0 ;
27157   Dali::KeyEvent::State temp6 ;
27158   Dali::KeyEvent *result = 0 ;
27159
27160   if (!jarg1) {
27161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27162     return 0;
27163   }
27164   std::string arg1_str(jarg1);
27165   arg1 = &arg1_str;
27166   if (!jarg2) {
27167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27168     return 0;
27169   }
27170   std::string arg2_str(jarg2);
27171   arg2 = &arg2_str;
27172   arg3 = (int)jarg3;
27173   arg4 = (int)jarg4;
27174   arg5 = (unsigned long)jarg5;
27175   temp6 = (Dali::KeyEvent::State)jarg6;
27176   arg6 = &temp6;
27177   {
27178     try {
27179       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
27180     } catch (std::out_of_range& e) {
27181       {
27182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27183       };
27184     } catch (std::exception& e) {
27185       {
27186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27187       };
27188     } catch (...) {
27189       {
27190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27191       };
27192     }
27193   }
27194   jresult = (void *)result;
27195
27196   //argout typemap for const std::string&
27197
27198
27199   //argout typemap for const std::string&
27200
27201   return jresult;
27202 }
27203
27204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
27205   void * jresult ;
27206   Dali::KeyEvent *arg1 = 0 ;
27207   Dali::KeyEvent *result = 0 ;
27208
27209   arg1 = (Dali::KeyEvent *)jarg1;
27210   if (!arg1) {
27211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
27212     return 0;
27213   }
27214   {
27215     try {
27216       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
27217     } catch (std::out_of_range& e) {
27218       {
27219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27220       };
27221     } catch (std::exception& e) {
27222       {
27223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27224       };
27225     } catch (...) {
27226       {
27227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27228       };
27229     }
27230   }
27231   jresult = (void *)result;
27232   return jresult;
27233 }
27234
27235
27236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
27237   void * jresult ;
27238   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27239   Dali::KeyEvent *arg2 = 0 ;
27240   Dali::KeyEvent *result = 0 ;
27241
27242   arg1 = (Dali::KeyEvent *)jarg1;
27243   arg2 = (Dali::KeyEvent *)jarg2;
27244   if (!arg2) {
27245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
27246     return 0;
27247   }
27248   {
27249     try {
27250       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
27251     } catch (std::out_of_range& e) {
27252       {
27253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27254       };
27255     } catch (std::exception& e) {
27256       {
27257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27258       };
27259     } catch (...) {
27260       {
27261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27262       };
27263     }
27264   }
27265   jresult = (void *)result;
27266   return jresult;
27267 }
27268
27269
27270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
27271   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27272
27273   arg1 = (Dali::KeyEvent *)jarg1;
27274   {
27275     try {
27276       delete arg1;
27277     } catch (std::out_of_range& e) {
27278       {
27279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27280       };
27281     } catch (std::exception& e) {
27282       {
27283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27284       };
27285     } catch (...) {
27286       {
27287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27288       };
27289     }
27290   }
27291 }
27292
27293
27294 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
27295   unsigned int jresult ;
27296   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27297   bool result;
27298
27299   arg1 = (Dali::KeyEvent *)jarg1;
27300   {
27301     try {
27302       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
27303     } catch (std::out_of_range& e) {
27304       {
27305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27306       };
27307     } catch (std::exception& e) {
27308       {
27309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27310       };
27311     } catch (...) {
27312       {
27313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27314       };
27315     }
27316   }
27317   jresult = result;
27318   return jresult;
27319 }
27320
27321
27322 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
27323   unsigned int jresult ;
27324   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27325   bool result;
27326
27327   arg1 = (Dali::KeyEvent *)jarg1;
27328   {
27329     try {
27330       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
27331     } catch (std::out_of_range& e) {
27332       {
27333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27334       };
27335     } catch (std::exception& e) {
27336       {
27337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27338       };
27339     } catch (...) {
27340       {
27341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27342       };
27343     }
27344   }
27345   jresult = result;
27346   return jresult;
27347 }
27348
27349
27350 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
27351   unsigned int jresult ;
27352   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27353   bool result;
27354
27355   arg1 = (Dali::KeyEvent *)jarg1;
27356   {
27357     try {
27358       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
27359     } catch (std::out_of_range& e) {
27360       {
27361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27362       };
27363     } catch (std::exception& e) {
27364       {
27365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27366       };
27367     } catch (...) {
27368       {
27369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27370       };
27371     }
27372   }
27373   jresult = result;
27374   return jresult;
27375 }
27376
27377
27378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
27379   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27380   std::string *arg2 = 0 ;
27381
27382   arg1 = (Dali::KeyEvent *)jarg1;
27383   if (!jarg2) {
27384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27385     return ;
27386   }
27387   std::string arg2_str(jarg2);
27388   arg2 = &arg2_str;
27389   if (arg1) (arg1)->keyPressedName = *arg2;
27390
27391   //argout typemap for const std::string&
27392
27393 }
27394
27395
27396 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
27397   char * jresult ;
27398   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27399   std::string *result = 0 ;
27400
27401   arg1 = (Dali::KeyEvent *)jarg1;
27402   result = (std::string *) & ((arg1)->keyPressedName);
27403   jresult = SWIG_csharp_string_callback(result->c_str());
27404   return jresult;
27405 }
27406
27407
27408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
27409   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27410   std::string *arg2 = 0 ;
27411
27412   arg1 = (Dali::KeyEvent *)jarg1;
27413   if (!jarg2) {
27414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27415     return ;
27416   }
27417   std::string arg2_str(jarg2);
27418   arg2 = &arg2_str;
27419   if (arg1) (arg1)->keyPressed = *arg2;
27420
27421   //argout typemap for const std::string&
27422
27423 }
27424
27425
27426 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
27427   char * jresult ;
27428   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27429   std::string *result = 0 ;
27430
27431   arg1 = (Dali::KeyEvent *)jarg1;
27432   result = (std::string *) & ((arg1)->keyPressed);
27433   jresult = SWIG_csharp_string_callback(result->c_str());
27434   return jresult;
27435 }
27436
27437
27438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
27439   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27440   int arg2 ;
27441
27442   arg1 = (Dali::KeyEvent *)jarg1;
27443   arg2 = (int)jarg2;
27444   if (arg1) (arg1)->keyCode = arg2;
27445 }
27446
27447
27448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
27449   int jresult ;
27450   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27451   int result;
27452
27453   arg1 = (Dali::KeyEvent *)jarg1;
27454   result = (int) ((arg1)->keyCode);
27455   jresult = result;
27456   return jresult;
27457 }
27458
27459
27460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
27461   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27462   int arg2 ;
27463
27464   arg1 = (Dali::KeyEvent *)jarg1;
27465   arg2 = (int)jarg2;
27466   if (arg1) (arg1)->keyModifier = arg2;
27467 }
27468
27469
27470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
27471   int jresult ;
27472   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27473   int result;
27474
27475   arg1 = (Dali::KeyEvent *)jarg1;
27476   result = (int) ((arg1)->keyModifier);
27477   jresult = result;
27478   return jresult;
27479 }
27480
27481
27482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
27483   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27484   unsigned long arg2 ;
27485
27486   arg1 = (Dali::KeyEvent *)jarg1;
27487   arg2 = (unsigned long)jarg2;
27488   if (arg1) (arg1)->time = arg2;
27489 }
27490
27491
27492 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
27493   unsigned long jresult ;
27494   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27495   unsigned long result;
27496
27497   arg1 = (Dali::KeyEvent *)jarg1;
27498   result = (unsigned long) ((arg1)->time);
27499   jresult = (unsigned long)result;
27500   return jresult;
27501 }
27502
27503
27504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
27505   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27506   Dali::KeyEvent::State arg2 ;
27507
27508   arg1 = (Dali::KeyEvent *)jarg1;
27509   arg2 = (Dali::KeyEvent::State)jarg2;
27510   if (arg1) (arg1)->state = arg2;
27511 }
27512
27513
27514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
27515   int jresult ;
27516   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27517   Dali::KeyEvent::State result;
27518
27519   arg1 = (Dali::KeyEvent *)jarg1;
27520   result = (Dali::KeyEvent::State) ((arg1)->state);
27521   jresult = (int)result;
27522   return jresult;
27523 }
27524
27525
27526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
27527   void * jresult ;
27528   Dali::LongPressGestureDetector *result = 0 ;
27529
27530   {
27531     try {
27532       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
27533     } catch (std::out_of_range& e) {
27534       {
27535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27536       };
27537     } catch (std::exception& e) {
27538       {
27539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27540       };
27541     } catch (...) {
27542       {
27543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27544       };
27545     }
27546   }
27547   jresult = (void *)result;
27548   return jresult;
27549 }
27550
27551
27552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
27553   void * jresult ;
27554   Dali::LongPressGestureDetector result;
27555
27556   {
27557     try {
27558       result = Dali::LongPressGestureDetector::New();
27559     } catch (std::out_of_range& e) {
27560       {
27561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27562       };
27563     } catch (std::exception& e) {
27564       {
27565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27566       };
27567     } catch (...) {
27568       {
27569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27570       };
27571     }
27572   }
27573   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27574   return jresult;
27575 }
27576
27577
27578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
27579   void * jresult ;
27580   unsigned int arg1 ;
27581   Dali::LongPressGestureDetector result;
27582
27583   arg1 = (unsigned int)jarg1;
27584   {
27585     try {
27586       result = Dali::LongPressGestureDetector::New(arg1);
27587     } catch (std::out_of_range& e) {
27588       {
27589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27590       };
27591     } catch (std::exception& e) {
27592       {
27593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27594       };
27595     } catch (...) {
27596       {
27597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27598       };
27599     }
27600   }
27601   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27602   return jresult;
27603 }
27604
27605
27606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
27607   void * jresult ;
27608   unsigned int arg1 ;
27609   unsigned int arg2 ;
27610   Dali::LongPressGestureDetector result;
27611
27612   arg1 = (unsigned int)jarg1;
27613   arg2 = (unsigned int)jarg2;
27614   {
27615     try {
27616       result = Dali::LongPressGestureDetector::New(arg1,arg2);
27617     } catch (std::out_of_range& e) {
27618       {
27619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27620       };
27621     } catch (std::exception& e) {
27622       {
27623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27624       };
27625     } catch (...) {
27626       {
27627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27628       };
27629     }
27630   }
27631   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27632   return jresult;
27633 }
27634
27635
27636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
27637   void * jresult ;
27638   Dali::BaseHandle arg1 ;
27639   Dali::BaseHandle *argp1 ;
27640   Dali::LongPressGestureDetector result;
27641
27642   argp1 = (Dali::BaseHandle *)jarg1;
27643   if (!argp1) {
27644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27645     return 0;
27646   }
27647   arg1 = *argp1;
27648   {
27649     try {
27650       result = Dali::LongPressGestureDetector::DownCast(arg1);
27651     } catch (std::out_of_range& e) {
27652       {
27653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27654       };
27655     } catch (std::exception& e) {
27656       {
27657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27658       };
27659     } catch (...) {
27660       {
27661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27662       };
27663     }
27664   }
27665   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27666   return jresult;
27667 }
27668
27669
27670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
27671   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27672
27673   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27674   {
27675     try {
27676       delete arg1;
27677     } catch (std::out_of_range& e) {
27678       {
27679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27680       };
27681     } catch (std::exception& e) {
27682       {
27683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27684       };
27685     } catch (...) {
27686       {
27687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27688       };
27689     }
27690   }
27691 }
27692
27693
27694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
27695   void * jresult ;
27696   Dali::LongPressGestureDetector *arg1 = 0 ;
27697   Dali::LongPressGestureDetector *result = 0 ;
27698
27699   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27700   if (!arg1) {
27701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27702     return 0;
27703   }
27704   {
27705     try {
27706       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
27707     } catch (std::out_of_range& e) {
27708       {
27709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27710       };
27711     } catch (std::exception& e) {
27712       {
27713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27714       };
27715     } catch (...) {
27716       {
27717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27718       };
27719     }
27720   }
27721   jresult = (void *)result;
27722   return jresult;
27723 }
27724
27725
27726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
27727   void * jresult ;
27728   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27729   Dali::LongPressGestureDetector *arg2 = 0 ;
27730   Dali::LongPressGestureDetector *result = 0 ;
27731
27732   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27733   arg2 = (Dali::LongPressGestureDetector *)jarg2;
27734   if (!arg2) {
27735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27736     return 0;
27737   }
27738   {
27739     try {
27740       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
27741     } catch (std::out_of_range& e) {
27742       {
27743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27744       };
27745     } catch (std::exception& e) {
27746       {
27747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27748       };
27749     } catch (...) {
27750       {
27751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27752       };
27753     }
27754   }
27755   jresult = (void *)result;
27756   return jresult;
27757 }
27758
27759
27760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
27761   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27762   unsigned int arg2 ;
27763
27764   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27765   arg2 = (unsigned int)jarg2;
27766   {
27767     try {
27768       (arg1)->SetTouchesRequired(arg2);
27769     } catch (std::out_of_range& e) {
27770       {
27771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27772       };
27773     } catch (std::exception& e) {
27774       {
27775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27776       };
27777     } catch (...) {
27778       {
27779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27780       };
27781     }
27782   }
27783 }
27784
27785
27786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
27787   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27788   unsigned int arg2 ;
27789   unsigned int arg3 ;
27790
27791   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27792   arg2 = (unsigned int)jarg2;
27793   arg3 = (unsigned int)jarg3;
27794   {
27795     try {
27796       (arg1)->SetTouchesRequired(arg2,arg3);
27797     } catch (std::out_of_range& e) {
27798       {
27799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27800       };
27801     } catch (std::exception& e) {
27802       {
27803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27804       };
27805     } catch (...) {
27806       {
27807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27808       };
27809     }
27810   }
27811 }
27812
27813
27814 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
27815   unsigned int jresult ;
27816   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27817   unsigned int result;
27818
27819   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27820   {
27821     try {
27822       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
27823     } catch (std::out_of_range& e) {
27824       {
27825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27826       };
27827     } catch (std::exception& e) {
27828       {
27829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27830       };
27831     } catch (...) {
27832       {
27833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27834       };
27835     }
27836   }
27837   jresult = result;
27838   return jresult;
27839 }
27840
27841
27842 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
27843   unsigned int jresult ;
27844   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27845   unsigned int result;
27846
27847   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27848   {
27849     try {
27850       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
27851     } catch (std::out_of_range& e) {
27852       {
27853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27854       };
27855     } catch (std::exception& e) {
27856       {
27857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27858       };
27859     } catch (...) {
27860       {
27861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27862       };
27863     }
27864   }
27865   jresult = result;
27866   return jresult;
27867 }
27868
27869
27870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
27871   void * jresult ;
27872   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27873   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
27874
27875   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27876   {
27877     try {
27878       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
27879     } catch (std::out_of_range& e) {
27880       {
27881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27882       };
27883     } catch (std::exception& e) {
27884       {
27885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27886       };
27887     } catch (...) {
27888       {
27889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27890       };
27891     }
27892   }
27893   jresult = (void *)result;
27894   return jresult;
27895 }
27896
27897
27898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
27899   void * jresult ;
27900   Dali::Gesture::State arg1 ;
27901   Dali::LongPressGesture *result = 0 ;
27902
27903   arg1 = (Dali::Gesture::State)jarg1;
27904   {
27905     try {
27906       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
27907     } catch (std::out_of_range& e) {
27908       {
27909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27910       };
27911     } catch (std::exception& e) {
27912       {
27913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27914       };
27915     } catch (...) {
27916       {
27917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27918       };
27919     }
27920   }
27921   jresult = (void *)result;
27922   return jresult;
27923 }
27924
27925
27926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
27927   void * jresult ;
27928   Dali::LongPressGesture *arg1 = 0 ;
27929   Dali::LongPressGesture *result = 0 ;
27930
27931   arg1 = (Dali::LongPressGesture *)jarg1;
27932   if (!arg1) {
27933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
27934     return 0;
27935   }
27936   {
27937     try {
27938       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
27939     } catch (std::out_of_range& e) {
27940       {
27941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27942       };
27943     } catch (std::exception& e) {
27944       {
27945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27946       };
27947     } catch (...) {
27948       {
27949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27950       };
27951     }
27952   }
27953   jresult = (void *)result;
27954   return jresult;
27955 }
27956
27957
27958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
27959   void * jresult ;
27960   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27961   Dali::LongPressGesture *arg2 = 0 ;
27962   Dali::LongPressGesture *result = 0 ;
27963
27964   arg1 = (Dali::LongPressGesture *)jarg1;
27965   arg2 = (Dali::LongPressGesture *)jarg2;
27966   if (!arg2) {
27967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
27968     return 0;
27969   }
27970   {
27971     try {
27972       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
27973     } catch (std::out_of_range& e) {
27974       {
27975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27976       };
27977     } catch (std::exception& e) {
27978       {
27979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27980       };
27981     } catch (...) {
27982       {
27983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27984       };
27985     }
27986   }
27987   jresult = (void *)result;
27988   return jresult;
27989 }
27990
27991
27992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
27993   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27994
27995   arg1 = (Dali::LongPressGesture *)jarg1;
27996   {
27997     try {
27998       delete arg1;
27999     } catch (std::out_of_range& e) {
28000       {
28001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28002       };
28003     } catch (std::exception& e) {
28004       {
28005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28006       };
28007     } catch (...) {
28008       {
28009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28010       };
28011     }
28012   }
28013 }
28014
28015
28016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
28017   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28018   unsigned int arg2 ;
28019
28020   arg1 = (Dali::LongPressGesture *)jarg1;
28021   arg2 = (unsigned int)jarg2;
28022   if (arg1) (arg1)->numberOfTouches = arg2;
28023 }
28024
28025
28026 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
28027   unsigned int jresult ;
28028   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28029   unsigned int result;
28030
28031   arg1 = (Dali::LongPressGesture *)jarg1;
28032   result = (unsigned int) ((arg1)->numberOfTouches);
28033   jresult = result;
28034   return jresult;
28035 }
28036
28037
28038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
28039   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28040   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28041
28042   arg1 = (Dali::LongPressGesture *)jarg1;
28043   arg2 = (Dali::Vector2 *)jarg2;
28044   if (arg1) (arg1)->screenPoint = *arg2;
28045 }
28046
28047
28048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
28049   void * jresult ;
28050   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28051   Dali::Vector2 *result = 0 ;
28052
28053   arg1 = (Dali::LongPressGesture *)jarg1;
28054   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
28055   jresult = (void *)result;
28056   return jresult;
28057 }
28058
28059
28060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
28061   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28062   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28063
28064   arg1 = (Dali::LongPressGesture *)jarg1;
28065   arg2 = (Dali::Vector2 *)jarg2;
28066   if (arg1) (arg1)->localPoint = *arg2;
28067 }
28068
28069
28070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
28071   void * jresult ;
28072   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28073   Dali::Vector2 *result = 0 ;
28074
28075   arg1 = (Dali::LongPressGesture *)jarg1;
28076   result = (Dali::Vector2 *)& ((arg1)->localPoint);
28077   jresult = (void *)result;
28078   return jresult;
28079 }
28080
28081
28082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
28083   void * jresult ;
28084   Dali::WheelEvent *result = 0 ;
28085
28086   {
28087     try {
28088       result = (Dali::WheelEvent *)new Dali::WheelEvent();
28089     } catch (std::out_of_range& e) {
28090       {
28091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28092       };
28093     } catch (std::exception& e) {
28094       {
28095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28096       };
28097     } catch (...) {
28098       {
28099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28100       };
28101     }
28102   }
28103   jresult = (void *)result;
28104   return jresult;
28105 }
28106
28107
28108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
28109   void * jresult ;
28110   Dali::WheelEvent::Type arg1 ;
28111   int arg2 ;
28112   unsigned int arg3 ;
28113   Dali::Vector2 arg4 ;
28114   int arg5 ;
28115   unsigned int arg6 ;
28116   Dali::Vector2 *argp4 ;
28117   Dali::WheelEvent *result = 0 ;
28118
28119   arg1 = (Dali::WheelEvent::Type)jarg1;
28120   arg2 = (int)jarg2;
28121   arg3 = (unsigned int)jarg3;
28122   argp4 = (Dali::Vector2 *)jarg4;
28123   if (!argp4) {
28124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28125     return 0;
28126   }
28127   arg4 = *argp4;
28128   arg5 = (int)jarg5;
28129   arg6 = (unsigned int)jarg6;
28130   {
28131     try {
28132       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
28133     } catch (std::out_of_range& e) {
28134       {
28135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28136       };
28137     } catch (std::exception& e) {
28138       {
28139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28140       };
28141     } catch (...) {
28142       {
28143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28144       };
28145     }
28146   }
28147   jresult = (void *)result;
28148   return jresult;
28149 }
28150
28151
28152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
28153   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28154
28155   arg1 = (Dali::WheelEvent *)jarg1;
28156   {
28157     try {
28158       delete arg1;
28159     } catch (std::out_of_range& e) {
28160       {
28161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28162       };
28163     } catch (std::exception& e) {
28164       {
28165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28166       };
28167     } catch (...) {
28168       {
28169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28170       };
28171     }
28172   }
28173 }
28174
28175
28176 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
28177   unsigned int jresult ;
28178   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28179   bool result;
28180
28181   arg1 = (Dali::WheelEvent *)jarg1;
28182   {
28183     try {
28184       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
28185     } catch (std::out_of_range& e) {
28186       {
28187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28188       };
28189     } catch (std::exception& e) {
28190       {
28191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28192       };
28193     } catch (...) {
28194       {
28195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28196       };
28197     }
28198   }
28199   jresult = result;
28200   return jresult;
28201 }
28202
28203
28204 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
28205   unsigned int jresult ;
28206   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28207   bool result;
28208
28209   arg1 = (Dali::WheelEvent *)jarg1;
28210   {
28211     try {
28212       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
28213     } catch (std::out_of_range& e) {
28214       {
28215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28216       };
28217     } catch (std::exception& e) {
28218       {
28219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28220       };
28221     } catch (...) {
28222       {
28223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28224       };
28225     }
28226   }
28227   jresult = result;
28228   return jresult;
28229 }
28230
28231
28232 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
28233   unsigned int jresult ;
28234   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28235   bool result;
28236
28237   arg1 = (Dali::WheelEvent *)jarg1;
28238   {
28239     try {
28240       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
28241     } catch (std::out_of_range& e) {
28242       {
28243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28244       };
28245     } catch (std::exception& e) {
28246       {
28247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28248       };
28249     } catch (...) {
28250       {
28251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28252       };
28253     }
28254   }
28255   jresult = result;
28256   return jresult;
28257 }
28258
28259
28260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
28261   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28262   Dali::WheelEvent::Type arg2 ;
28263
28264   arg1 = (Dali::WheelEvent *)jarg1;
28265   arg2 = (Dali::WheelEvent::Type)jarg2;
28266   if (arg1) (arg1)->type = arg2;
28267 }
28268
28269
28270 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
28271   int jresult ;
28272   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28273   Dali::WheelEvent::Type result;
28274
28275   arg1 = (Dali::WheelEvent *)jarg1;
28276   result = (Dali::WheelEvent::Type) ((arg1)->type);
28277   jresult = (int)result;
28278   return jresult;
28279 }
28280
28281
28282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
28283   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28284   int arg2 ;
28285
28286   arg1 = (Dali::WheelEvent *)jarg1;
28287   arg2 = (int)jarg2;
28288   if (arg1) (arg1)->direction = arg2;
28289 }
28290
28291
28292 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
28293   int jresult ;
28294   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28295   int result;
28296
28297   arg1 = (Dali::WheelEvent *)jarg1;
28298   result = (int) ((arg1)->direction);
28299   jresult = result;
28300   return jresult;
28301 }
28302
28303
28304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
28305   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28306   unsigned int arg2 ;
28307
28308   arg1 = (Dali::WheelEvent *)jarg1;
28309   arg2 = (unsigned int)jarg2;
28310   if (arg1) (arg1)->modifiers = arg2;
28311 }
28312
28313
28314 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
28315   unsigned int jresult ;
28316   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28317   unsigned int result;
28318
28319   arg1 = (Dali::WheelEvent *)jarg1;
28320   result = (unsigned int) ((arg1)->modifiers);
28321   jresult = result;
28322   return jresult;
28323 }
28324
28325
28326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
28327   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28328   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28329
28330   arg1 = (Dali::WheelEvent *)jarg1;
28331   arg2 = (Dali::Vector2 *)jarg2;
28332   if (arg1) (arg1)->point = *arg2;
28333 }
28334
28335
28336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
28337   void * jresult ;
28338   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28339   Dali::Vector2 *result = 0 ;
28340
28341   arg1 = (Dali::WheelEvent *)jarg1;
28342   result = (Dali::Vector2 *)& ((arg1)->point);
28343   jresult = (void *)result;
28344   return jresult;
28345 }
28346
28347
28348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
28349   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28350   int arg2 ;
28351
28352   arg1 = (Dali::WheelEvent *)jarg1;
28353   arg2 = (int)jarg2;
28354   if (arg1) (arg1)->z = arg2;
28355 }
28356
28357
28358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
28359   int jresult ;
28360   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28361   int result;
28362
28363   arg1 = (Dali::WheelEvent *)jarg1;
28364   result = (int) ((arg1)->z);
28365   jresult = result;
28366   return jresult;
28367 }
28368
28369
28370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
28371   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28372   unsigned int arg2 ;
28373
28374   arg1 = (Dali::WheelEvent *)jarg1;
28375   arg2 = (unsigned int)jarg2;
28376   if (arg1) (arg1)->timeStamp = arg2;
28377 }
28378
28379
28380 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
28381   unsigned int jresult ;
28382   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28383   unsigned int result;
28384
28385   arg1 = (Dali::WheelEvent *)jarg1;
28386   result = (unsigned int) ((arg1)->timeStamp);
28387   jresult = result;
28388   return jresult;
28389 }
28390
28391 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
28392   char * jresult ;
28393   Dali::KeyEvent *arg1 = 0 ;
28394   std::string result;
28395
28396   arg1 = (Dali::KeyEvent *)jarg1;
28397   if (!arg1) {
28398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
28399     return 0;
28400   }
28401   {
28402     try {
28403       result = arg1->GetDeviceName();
28404     } catch (std::out_of_range& e) {
28405       {
28406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28407       };
28408     } catch (std::exception& e) {
28409       {
28410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28411       };
28412     } catch (...) {
28413       {
28414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28415       };
28416     }
28417   }
28418   jresult = SWIG_csharp_string_callback((&result)->c_str());
28419   return jresult;
28420 }
28421
28422 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
28423   int jresult ;
28424   Dali::KeyEvent *arg1 = 0 ;
28425   Dali::Device::Class::Type result;
28426
28427   arg1 = (Dali::KeyEvent *)jarg1;
28428   if (!arg1) {
28429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
28430     return 0;
28431   }
28432   {
28433     try {
28434       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
28435     } catch (std::out_of_range& e) {
28436       {
28437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28438       };
28439     } catch (std::exception& e) {
28440       {
28441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28442       };
28443     } catch (...) {
28444       {
28445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28446       };
28447     }
28448   }
28449   jresult = (int)result;
28450   return jresult;
28451 }
28452
28453
28454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
28455   Dali::Actor arg1 ;
28456   Dali::Actor *argp1 ;
28457
28458   argp1 = (Dali::Actor *)jarg1;
28459   if (!argp1) {
28460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28461     return ;
28462   }
28463   arg1 = *argp1;
28464   {
28465     try {
28466       Dali::DevelActor::Raise(arg1);
28467     } catch (std::out_of_range& e) {
28468       {
28469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28470       };
28471     } catch (std::exception& e) {
28472       {
28473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28474       };
28475     } catch (...) {
28476       {
28477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28478       };
28479     }
28480   }
28481 }
28482
28483
28484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
28485   Dali::Actor arg1 ;
28486   Dali::Actor *argp1 ;
28487
28488   argp1 = (Dali::Actor *)jarg1;
28489   if (!argp1) {
28490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28491     return ;
28492   }
28493   arg1 = *argp1;
28494   {
28495     try {
28496       Dali::DevelActor::Lower(arg1);
28497     } catch (std::out_of_range& e) {
28498       {
28499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28500       };
28501     } catch (std::exception& e) {
28502       {
28503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28504       };
28505     } catch (...) {
28506       {
28507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28508       };
28509     }
28510   }
28511 }
28512
28513
28514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
28515   Dali::Actor arg1 ;
28516   Dali::Actor *argp1 ;
28517
28518   argp1 = (Dali::Actor *)jarg1;
28519   if (!argp1) {
28520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28521     return ;
28522   }
28523   arg1 = *argp1;
28524   {
28525     try {
28526       Dali::DevelActor::RaiseToTop(arg1);
28527     } catch (std::out_of_range& e) {
28528       {
28529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28530       };
28531     } catch (std::exception& e) {
28532       {
28533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28534       };
28535     } catch (...) {
28536       {
28537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28538       };
28539     }
28540   }
28541 }
28542
28543
28544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
28545   Dali::Actor arg1 ;
28546   Dali::Actor *argp1 ;
28547
28548   argp1 = (Dali::Actor *)jarg1;
28549   if (!argp1) {
28550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28551     return ;
28552   }
28553   arg1 = *argp1;
28554   {
28555     try {
28556       Dali::DevelActor::LowerToBottom(arg1);
28557     } catch (std::out_of_range& e) {
28558       {
28559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28560       };
28561     } catch (std::exception& e) {
28562       {
28563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28564       };
28565     } catch (...) {
28566       {
28567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28568       };
28569     }
28570   }
28571 }
28572
28573
28574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
28575   Dali::Actor arg1 ;
28576   Dali::Actor arg2 ;
28577   Dali::Actor *argp1 ;
28578   Dali::Actor *argp2 ;
28579
28580   argp1 = (Dali::Actor *)jarg1;
28581   if (!argp1) {
28582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28583     return ;
28584   }
28585   arg1 = *argp1;
28586   argp2 = (Dali::Actor *)jarg2;
28587   if (!argp2) {
28588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28589     return ;
28590   }
28591   arg2 = *argp2;
28592   {
28593     try {
28594       Dali::DevelActor::RaiseAbove(arg1,arg2);
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_LowerBelow(void * jarg1, void * jarg2) {
28613   Dali::Actor arg1 ;
28614   Dali::Actor arg2 ;
28615   Dali::Actor *argp1 ;
28616   Dali::Actor *argp2 ;
28617
28618   argp1 = (Dali::Actor *)jarg1;
28619   if (!argp1) {
28620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28621     return ;
28622   }
28623   arg1 = *argp1;
28624   argp2 = (Dali::Actor *)jarg2;
28625   if (!argp2) {
28626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28627     return ;
28628   }
28629   arg2 = *argp2;
28630   {
28631     try {
28632       Dali::DevelActor::LowerBelow(arg1,arg2);
28633     } catch (std::out_of_range& e) {
28634       {
28635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28636       };
28637     } catch (std::exception& e) {
28638       {
28639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28640       };
28641     } catch (...) {
28642       {
28643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28644       };
28645     }
28646   }
28647 }
28648
28649
28650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
28651   void * jresult ;
28652   Dali::Actor arg1 ;
28653   Dali::Actor *argp1 ;
28654   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
28655
28656   argp1 = (Dali::Actor *)jarg1;
28657   if (!argp1) {
28658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28659     return 0;
28660   }
28661   arg1 = *argp1;
28662   {
28663     try {
28664       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
28665     } catch (std::out_of_range& e) {
28666       {
28667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28668       };
28669     } catch (std::exception& e) {
28670       {
28671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28672       };
28673     } catch (...) {
28674       {
28675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28676       };
28677     }
28678   }
28679   jresult = (void *)result;
28680   return jresult;
28681 }
28682
28683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
28684   int jresult ;
28685   int result;
28686
28687   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
28688   jresult = (int)result;
28689   return jresult;
28690 }
28691
28692
28693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
28694   int jresult ;
28695   int result;
28696
28697   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
28698   jresult = (int)result;
28699   return jresult;
28700 }
28701
28702
28703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
28704   int jresult ;
28705   int result;
28706
28707   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
28708   jresult = (int)result;
28709   return jresult;
28710 }
28711
28712
28713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
28714   int jresult ;
28715   int result;
28716
28717   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
28718   jresult = (int)result;
28719   return jresult;
28720 }
28721
28722
28723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
28724   int jresult ;
28725   int result;
28726
28727   result = (int)Dali::Actor::Property::ANCHOR_POINT;
28728   jresult = (int)result;
28729   return jresult;
28730 }
28731
28732
28733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
28734   int jresult ;
28735   int result;
28736
28737   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
28738   jresult = (int)result;
28739   return jresult;
28740 }
28741
28742
28743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
28744   int jresult ;
28745   int result;
28746
28747   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
28748   jresult = (int)result;
28749   return jresult;
28750 }
28751
28752
28753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
28754   int jresult ;
28755   int result;
28756
28757   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
28758   jresult = (int)result;
28759   return jresult;
28760 }
28761
28762
28763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
28764   int jresult ;
28765   int result;
28766
28767   result = (int)Dali::Actor::Property::SIZE;
28768   jresult = (int)result;
28769   return jresult;
28770 }
28771
28772
28773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
28774   int jresult ;
28775   int result;
28776
28777   result = (int)Dali::Actor::Property::SIZE_WIDTH;
28778   jresult = (int)result;
28779   return jresult;
28780 }
28781
28782
28783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
28784   int jresult ;
28785   int result;
28786
28787   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
28788   jresult = (int)result;
28789   return jresult;
28790 }
28791
28792
28793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
28794   int jresult ;
28795   int result;
28796
28797   result = (int)Dali::Actor::Property::SIZE_DEPTH;
28798   jresult = (int)result;
28799   return jresult;
28800 }
28801
28802
28803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
28804   int jresult ;
28805   int result;
28806
28807   result = (int)Dali::Actor::Property::POSITION;
28808   jresult = (int)result;
28809   return jresult;
28810 }
28811
28812
28813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
28814   int jresult ;
28815   int result;
28816
28817   result = (int)Dali::Actor::Property::POSITION_X;
28818   jresult = (int)result;
28819   return jresult;
28820 }
28821
28822
28823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
28824   int jresult ;
28825   int result;
28826
28827   result = (int)Dali::Actor::Property::POSITION_Y;
28828   jresult = (int)result;
28829   return jresult;
28830 }
28831
28832
28833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
28834   int jresult ;
28835   int result;
28836
28837   result = (int)Dali::Actor::Property::POSITION_Z;
28838   jresult = (int)result;
28839   return jresult;
28840 }
28841
28842
28843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
28844   int jresult ;
28845   int result;
28846
28847   result = (int)Dali::Actor::Property::WORLD_POSITION;
28848   jresult = (int)result;
28849   return jresult;
28850 }
28851
28852
28853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
28854   int jresult ;
28855   int result;
28856
28857   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
28858   jresult = (int)result;
28859   return jresult;
28860 }
28861
28862
28863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
28864   int jresult ;
28865   int result;
28866
28867   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
28868   jresult = (int)result;
28869   return jresult;
28870 }
28871
28872
28873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
28874   int jresult ;
28875   int result;
28876
28877   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
28878   jresult = (int)result;
28879   return jresult;
28880 }
28881
28882
28883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
28884   int jresult ;
28885   int result;
28886
28887   result = (int)Dali::Actor::Property::ORIENTATION;
28888   jresult = (int)result;
28889   return jresult;
28890 }
28891
28892
28893 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
28894   int jresult ;
28895   int result;
28896
28897   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
28898   jresult = (int)result;
28899   return jresult;
28900 }
28901
28902
28903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
28904   int jresult ;
28905   int result;
28906
28907   result = (int)Dali::Actor::Property::SCALE;
28908   jresult = (int)result;
28909   return jresult;
28910 }
28911
28912
28913 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
28914   int jresult ;
28915   int result;
28916
28917   result = (int)Dali::Actor::Property::SCALE_X;
28918   jresult = (int)result;
28919   return jresult;
28920 }
28921
28922
28923 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
28924   int jresult ;
28925   int result;
28926
28927   result = (int)Dali::Actor::Property::SCALE_Y;
28928   jresult = (int)result;
28929   return jresult;
28930 }
28931
28932
28933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
28934   int jresult ;
28935   int result;
28936
28937   result = (int)Dali::Actor::Property::SCALE_Z;
28938   jresult = (int)result;
28939   return jresult;
28940 }
28941
28942
28943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
28944   int jresult ;
28945   int result;
28946
28947   result = (int)Dali::Actor::Property::WORLD_SCALE;
28948   jresult = (int)result;
28949   return jresult;
28950 }
28951
28952
28953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
28954   int jresult ;
28955   int result;
28956
28957   result = (int)Dali::Actor::Property::VISIBLE;
28958   jresult = (int)result;
28959   return jresult;
28960 }
28961
28962
28963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
28964   int jresult ;
28965   int result;
28966
28967   result = (int)Dali::Actor::Property::COLOR;
28968   jresult = (int)result;
28969   return jresult;
28970 }
28971
28972
28973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
28974   int jresult ;
28975   int result;
28976
28977   result = (int)Dali::Actor::Property::COLOR_RED;
28978   jresult = (int)result;
28979   return jresult;
28980 }
28981
28982
28983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
28984   int jresult ;
28985   int result;
28986
28987   result = (int)Dali::Actor::Property::COLOR_GREEN;
28988   jresult = (int)result;
28989   return jresult;
28990 }
28991
28992
28993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
28994   int jresult ;
28995   int result;
28996
28997   result = (int)Dali::Actor::Property::COLOR_BLUE;
28998   jresult = (int)result;
28999   return jresult;
29000 }
29001
29002
29003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
29004   int jresult ;
29005   int result;
29006
29007   result = (int)Dali::Actor::Property::COLOR_ALPHA;
29008   jresult = (int)result;
29009   return jresult;
29010 }
29011
29012
29013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
29014   int jresult ;
29015   int result;
29016
29017   result = (int)Dali::Actor::Property::WORLD_COLOR;
29018   jresult = (int)result;
29019   return jresult;
29020 }
29021
29022
29023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
29024   int jresult ;
29025   int result;
29026
29027   result = (int)Dali::Actor::Property::WORLD_MATRIX;
29028   jresult = (int)result;
29029   return jresult;
29030 }
29031
29032
29033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
29034   int jresult ;
29035   int result;
29036
29037   result = (int)Dali::Actor::Property::NAME;
29038   jresult = (int)result;
29039   return jresult;
29040 }
29041
29042
29043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
29044   int jresult ;
29045   int result;
29046
29047   result = (int)Dali::Actor::Property::SENSITIVE;
29048   jresult = (int)result;
29049   return jresult;
29050 }
29051
29052
29053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
29054   int jresult ;
29055   int result;
29056
29057   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
29058   jresult = (int)result;
29059   return jresult;
29060 }
29061
29062
29063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
29064   int jresult ;
29065   int result;
29066
29067   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
29068   jresult = (int)result;
29069   return jresult;
29070 }
29071
29072
29073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
29074   int jresult ;
29075   int result;
29076
29077   result = (int)Dali::Actor::Property::INHERIT_SCALE;
29078   jresult = (int)result;
29079   return jresult;
29080 }
29081
29082
29083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
29084   int jresult ;
29085   int result;
29086
29087   result = (int)Dali::Actor::Property::COLOR_MODE;
29088   jresult = (int)result;
29089   return jresult;
29090 }
29091
29092
29093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_INHERITANCE_get() {
29094   int jresult ;
29095   int result;
29096
29097   result = (int)Dali::Actor::Property::POSITION_INHERITANCE;
29098   jresult = (int)result;
29099   return jresult;
29100 }
29101
29102
29103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
29104   int jresult ;
29105   int result;
29106
29107   result = (int)Dali::Actor::Property::DRAW_MODE;
29108   jresult = (int)result;
29109   return jresult;
29110 }
29111
29112
29113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
29114   int jresult ;
29115   int result;
29116
29117   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
29118   jresult = (int)result;
29119   return jresult;
29120 }
29121
29122
29123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
29124   int jresult ;
29125   int result;
29126
29127   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
29128   jresult = (int)result;
29129   return jresult;
29130 }
29131
29132
29133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
29134   int jresult ;
29135   int result;
29136
29137   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
29138   jresult = (int)result;
29139   return jresult;
29140 }
29141
29142
29143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
29144   int jresult ;
29145   int result;
29146
29147   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
29148   jresult = (int)result;
29149   return jresult;
29150 }
29151
29152
29153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
29154   int jresult ;
29155   int result;
29156
29157   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
29158   jresult = (int)result;
29159   return jresult;
29160 }
29161
29162
29163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
29164   int jresult ;
29165   int result;
29166
29167   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
29168   jresult = (int)result;
29169   return jresult;
29170 }
29171
29172
29173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
29174   int jresult ;
29175   int result;
29176
29177   result = (int)Dali::Actor::Property::PADDING;
29178   jresult = (int)result;
29179   return jresult;
29180 }
29181
29182
29183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
29184   int jresult ;
29185   int result;
29186
29187   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
29188   jresult = (int)result;
29189   return jresult;
29190 }
29191
29192
29193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
29194   int jresult ;
29195   int result;
29196
29197   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
29198   jresult = (int)result;
29199   return jresult;
29200 }
29201
29202
29203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
29204   int jresult ;
29205   int result;
29206
29207   result = (int)Dali::Actor::Property::INHERIT_POSITION;
29208   jresult = (int)result;
29209   return jresult;
29210 }
29211
29212
29213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
29214   int jresult ;
29215   int result;
29216
29217   result = (int)Dali::Actor::Property::CLIPPING_MODE;
29218   jresult = (int)result;
29219   return jresult;
29220 }
29221
29222
29223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
29224   void * jresult ;
29225   Dali::Actor::Property *result = 0 ;
29226
29227   {
29228     try {
29229       result = (Dali::Actor::Property *)new Dali::Actor::Property();
29230     } catch (std::out_of_range& e) {
29231       {
29232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29233       };
29234     } catch (std::exception& e) {
29235       {
29236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29237       };
29238     } catch (...) {
29239       {
29240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29241       };
29242     }
29243   }
29244   jresult = (void *)result;
29245   return jresult;
29246 }
29247
29248
29249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
29250   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
29251
29252   arg1 = (Dali::Actor::Property *)jarg1;
29253   {
29254     try {
29255       delete arg1;
29256     } catch (std::out_of_range& e) {
29257       {
29258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29259       };
29260     } catch (std::exception& e) {
29261       {
29262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29263       };
29264     } catch (...) {
29265       {
29266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29267       };
29268     }
29269   }
29270 }
29271
29272
29273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
29274   void * jresult ;
29275   Dali::Actor *result = 0 ;
29276
29277   {
29278     try {
29279       result = (Dali::Actor *)new Dali::Actor();
29280     } catch (std::out_of_range& e) {
29281       {
29282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29283       };
29284     } catch (std::exception& e) {
29285       {
29286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29287       };
29288     } catch (...) {
29289       {
29290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29291       };
29292     }
29293   }
29294   jresult = (void *)result;
29295   return jresult;
29296 }
29297
29298
29299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
29300   void * jresult ;
29301   Dali::Actor result;
29302
29303   {
29304     try {
29305       result = Dali::Actor::New();
29306     } catch (std::out_of_range& e) {
29307       {
29308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29309       };
29310     } catch (std::exception& e) {
29311       {
29312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29313       };
29314     } catch (...) {
29315       {
29316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29317       };
29318     }
29319   }
29320   jresult = new Dali::Actor((const Dali::Actor &)result);
29321   return jresult;
29322 }
29323
29324
29325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
29326   void * jresult ;
29327   Dali::BaseHandle arg1 ;
29328   Dali::BaseHandle *argp1 ;
29329   Dali::Actor result;
29330
29331   argp1 = (Dali::BaseHandle *)jarg1;
29332   if (!argp1) {
29333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
29334     return 0;
29335   }
29336   arg1 = *argp1;
29337   {
29338     try {
29339       result = Dali::Actor::DownCast(arg1);
29340     } catch (std::out_of_range& e) {
29341       {
29342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29343       };
29344     } catch (std::exception& e) {
29345       {
29346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29347       };
29348     } catch (...) {
29349       {
29350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29351       };
29352     }
29353   }
29354   jresult = new Dali::Actor((const Dali::Actor &)result);
29355   return jresult;
29356 }
29357
29358
29359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
29360   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29361
29362   arg1 = (Dali::Actor *)jarg1;
29363   {
29364     try {
29365       delete arg1;
29366     } catch (std::out_of_range& e) {
29367       {
29368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29369       };
29370     } catch (std::exception& e) {
29371       {
29372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29373       };
29374     } catch (...) {
29375       {
29376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29377       };
29378     }
29379   }
29380 }
29381
29382
29383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
29384   void * jresult ;
29385   Dali::Actor *arg1 = 0 ;
29386   Dali::Actor *result = 0 ;
29387
29388   arg1 = (Dali::Actor *)jarg1;
29389   if (!arg1) {
29390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29391     return 0;
29392   }
29393   {
29394     try {
29395       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
29396     } catch (std::out_of_range& e) {
29397       {
29398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29399       };
29400     } catch (std::exception& e) {
29401       {
29402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29403       };
29404     } catch (...) {
29405       {
29406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29407       };
29408     }
29409   }
29410   jresult = (void *)result;
29411   return jresult;
29412 }
29413
29414
29415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
29416   void * jresult ;
29417   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29418   Dali::Actor *arg2 = 0 ;
29419   Dali::Actor *result = 0 ;
29420
29421   arg1 = (Dali::Actor *)jarg1;
29422   arg2 = (Dali::Actor *)jarg2;
29423   if (!arg2) {
29424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29425     return 0;
29426   }
29427   {
29428     try {
29429       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
29430     } catch (std::out_of_range& e) {
29431       {
29432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29433       };
29434     } catch (std::exception& e) {
29435       {
29436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29437       };
29438     } catch (...) {
29439       {
29440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29441       };
29442     }
29443   }
29444   jresult = (void *)result;
29445   return jresult;
29446 }
29447
29448
29449 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
29450   char * jresult ;
29451   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29452   std::string *result = 0 ;
29453
29454   arg1 = (Dali::Actor *)jarg1;
29455   {
29456     try {
29457       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
29458     } catch (std::out_of_range& e) {
29459       {
29460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29461       };
29462     } catch (std::exception& e) {
29463       {
29464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29465       };
29466     } catch (...) {
29467       {
29468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29469       };
29470     }
29471   }
29472   jresult = SWIG_csharp_string_callback(result->c_str());
29473   return jresult;
29474 }
29475
29476
29477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
29478   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29479   std::string *arg2 = 0 ;
29480
29481   arg1 = (Dali::Actor *)jarg1;
29482   if (!jarg2) {
29483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29484     return ;
29485   }
29486   std::string arg2_str(jarg2);
29487   arg2 = &arg2_str;
29488   {
29489     try {
29490       (arg1)->SetName((std::string const &)*arg2);
29491     } catch (std::out_of_range& e) {
29492       {
29493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29494       };
29495     } catch (std::exception& e) {
29496       {
29497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29498       };
29499     } catch (...) {
29500       {
29501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29502       };
29503     }
29504   }
29505
29506   //argout typemap for const std::string&
29507
29508 }
29509
29510
29511 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
29512   unsigned int jresult ;
29513   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29514   unsigned int result;
29515
29516   arg1 = (Dali::Actor *)jarg1;
29517   {
29518     try {
29519       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
29520     } catch (std::out_of_range& e) {
29521       {
29522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29523       };
29524     } catch (std::exception& e) {
29525       {
29526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29527       };
29528     } catch (...) {
29529       {
29530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29531       };
29532     }
29533   }
29534   jresult = result;
29535   return jresult;
29536 }
29537
29538
29539 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
29540   unsigned int jresult ;
29541   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29542   bool result;
29543
29544   arg1 = (Dali::Actor *)jarg1;
29545   {
29546     try {
29547       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
29548     } catch (std::out_of_range& e) {
29549       {
29550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29551       };
29552     } catch (std::exception& e) {
29553       {
29554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29555       };
29556     } catch (...) {
29557       {
29558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29559       };
29560     }
29561   }
29562   jresult = result;
29563   return jresult;
29564 }
29565
29566
29567 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
29568   unsigned int jresult ;
29569   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29570   bool result;
29571
29572   arg1 = (Dali::Actor *)jarg1;
29573   {
29574     try {
29575       result = (bool)((Dali::Actor const *)arg1)->OnStage();
29576     } catch (std::out_of_range& e) {
29577       {
29578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29579       };
29580     } catch (std::exception& e) {
29581       {
29582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29583       };
29584     } catch (...) {
29585       {
29586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29587       };
29588     }
29589   }
29590   jresult = result;
29591   return jresult;
29592 }
29593
29594
29595 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
29596   unsigned int jresult ;
29597   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29598   bool result;
29599
29600   arg1 = (Dali::Actor *)jarg1;
29601   {
29602     try {
29603       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
29604     } catch (std::out_of_range& e) {
29605       {
29606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29607       };
29608     } catch (std::exception& e) {
29609       {
29610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29611       };
29612     } catch (...) {
29613       {
29614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29615       };
29616     }
29617   }
29618   jresult = result;
29619   return jresult;
29620 }
29621
29622
29623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
29624   void * jresult ;
29625   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29626   Dali::Layer result;
29627
29628   arg1 = (Dali::Actor *)jarg1;
29629   {
29630     try {
29631       result = (arg1)->GetLayer();
29632     } catch (std::out_of_range& e) {
29633       {
29634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29635       };
29636     } catch (std::exception& e) {
29637       {
29638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29639       };
29640     } catch (...) {
29641       {
29642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29643       };
29644     }
29645   }
29646   jresult = new Dali::Layer((const Dali::Layer &)result);
29647   return jresult;
29648 }
29649
29650
29651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
29652   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29653   Dali::Actor arg2 ;
29654   Dali::Actor *argp2 ;
29655
29656   arg1 = (Dali::Actor *)jarg1;
29657   argp2 = (Dali::Actor *)jarg2;
29658   if (!argp2) {
29659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29660     return ;
29661   }
29662   arg2 = *argp2;
29663   {
29664     try {
29665       (arg1)->Add(arg2);
29666     } catch (std::out_of_range& e) {
29667       {
29668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29669       };
29670     } catch (std::exception& e) {
29671       {
29672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29673       };
29674     } catch (...) {
29675       {
29676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29677       };
29678     }
29679   }
29680 }
29681
29682
29683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
29684   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29685   Dali::Actor arg2 ;
29686   Dali::Actor *argp2 ;
29687
29688   arg1 = (Dali::Actor *)jarg1;
29689   argp2 = (Dali::Actor *)jarg2;
29690   if (!argp2) {
29691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29692     return ;
29693   }
29694   arg2 = *argp2;
29695   {
29696     try {
29697       (arg1)->Remove(arg2);
29698     } catch (std::out_of_range& e) {
29699       {
29700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29701       };
29702     } catch (std::exception& e) {
29703       {
29704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29705       };
29706     } catch (...) {
29707       {
29708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29709       };
29710     }
29711   }
29712 }
29713
29714
29715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
29716   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29717
29718   arg1 = (Dali::Actor *)jarg1;
29719   {
29720     try {
29721       (arg1)->Unparent();
29722     } catch (std::out_of_range& e) {
29723       {
29724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29725       };
29726     } catch (std::exception& e) {
29727       {
29728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29729       };
29730     } catch (...) {
29731       {
29732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29733       };
29734     }
29735   }
29736 }
29737
29738
29739 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
29740   unsigned int jresult ;
29741   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29742   unsigned int result;
29743
29744   arg1 = (Dali::Actor *)jarg1;
29745   {
29746     try {
29747       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
29748     } catch (std::out_of_range& e) {
29749       {
29750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29751       };
29752     } catch (std::exception& e) {
29753       {
29754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29755       };
29756     } catch (...) {
29757       {
29758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29759       };
29760     }
29761   }
29762   jresult = result;
29763   return jresult;
29764 }
29765
29766
29767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
29768   void * jresult ;
29769   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29770   unsigned int arg2 ;
29771   Dali::Actor result;
29772
29773   arg1 = (Dali::Actor *)jarg1;
29774   arg2 = (unsigned int)jarg2;
29775   {
29776     try {
29777       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
29778     } catch (std::out_of_range& e) {
29779       {
29780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29781       };
29782     } catch (std::exception& e) {
29783       {
29784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29785       };
29786     } catch (...) {
29787       {
29788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29789       };
29790     }
29791   }
29792   jresult = new Dali::Actor((const Dali::Actor &)result);
29793   return jresult;
29794 }
29795
29796
29797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
29798   void * jresult ;
29799   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29800   std::string *arg2 = 0 ;
29801   Dali::Actor result;
29802
29803   arg1 = (Dali::Actor *)jarg1;
29804   if (!jarg2) {
29805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29806     return 0;
29807   }
29808   std::string arg2_str(jarg2);
29809   arg2 = &arg2_str;
29810   {
29811     try {
29812       result = (arg1)->FindChildByName((std::string const &)*arg2);
29813     } catch (std::out_of_range& e) {
29814       {
29815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29816       };
29817     } catch (std::exception& e) {
29818       {
29819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29820       };
29821     } catch (...) {
29822       {
29823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29824       };
29825     }
29826   }
29827   jresult = new Dali::Actor((const Dali::Actor &)result);
29828
29829   //argout typemap for const std::string&
29830
29831   return jresult;
29832 }
29833
29834
29835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
29836   void * jresult ;
29837   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29838   unsigned int arg2 ;
29839   Dali::Actor result;
29840
29841   arg1 = (Dali::Actor *)jarg1;
29842   arg2 = (unsigned int)jarg2;
29843   {
29844     try {
29845       result = (arg1)->FindChildById(arg2);
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 = new Dali::Actor((const Dali::Actor &)result);
29861   return jresult;
29862 }
29863
29864
29865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
29866   void * jresult ;
29867   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29868   Dali::Actor result;
29869
29870   arg1 = (Dali::Actor *)jarg1;
29871   {
29872     try {
29873       result = ((Dali::Actor const *)arg1)->GetParent();
29874     } catch (std::out_of_range& e) {
29875       {
29876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29877       };
29878     } catch (std::exception& e) {
29879       {
29880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29881       };
29882     } catch (...) {
29883       {
29884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29885       };
29886     }
29887   }
29888   jresult = new Dali::Actor((const Dali::Actor &)result);
29889   return jresult;
29890 }
29891
29892
29893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
29894   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29895   Dali::Vector3 *arg2 = 0 ;
29896
29897   arg1 = (Dali::Actor *)jarg1;
29898   arg2 = (Dali::Vector3 *)jarg2;
29899   if (!arg2) {
29900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29901     return ;
29902   }
29903   {
29904     try {
29905       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
29906     } catch (std::out_of_range& e) {
29907       {
29908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29909       };
29910     } catch (std::exception& e) {
29911       {
29912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29913       };
29914     } catch (...) {
29915       {
29916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29917       };
29918     }
29919   }
29920 }
29921
29922
29923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
29924   void * jresult ;
29925   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29926   Dali::Vector3 result;
29927
29928   arg1 = (Dali::Actor *)jarg1;
29929   {
29930     try {
29931       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
29932     } catch (std::out_of_range& e) {
29933       {
29934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29935       };
29936     } catch (std::exception& e) {
29937       {
29938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29939       };
29940     } catch (...) {
29941       {
29942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29943       };
29944     }
29945   }
29946   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29947   return jresult;
29948 }
29949
29950
29951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
29952   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29953   Dali::Vector3 *arg2 = 0 ;
29954
29955   arg1 = (Dali::Actor *)jarg1;
29956   arg2 = (Dali::Vector3 *)jarg2;
29957   if (!arg2) {
29958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29959     return ;
29960   }
29961   {
29962     try {
29963       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
29964     } catch (std::out_of_range& e) {
29965       {
29966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29967       };
29968     } catch (std::exception& e) {
29969       {
29970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29971       };
29972     } catch (...) {
29973       {
29974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29975       };
29976     }
29977   }
29978 }
29979
29980
29981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
29982   void * jresult ;
29983   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29984   Dali::Vector3 result;
29985
29986   arg1 = (Dali::Actor *)jarg1;
29987   {
29988     try {
29989       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
29990     } catch (std::out_of_range& e) {
29991       {
29992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29993       };
29994     } catch (std::exception& e) {
29995       {
29996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29997       };
29998     } catch (...) {
29999       {
30000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30001       };
30002     }
30003   }
30004   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30005   return jresult;
30006 }
30007
30008
30009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
30010   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30011   float arg2 ;
30012   float arg3 ;
30013
30014   arg1 = (Dali::Actor *)jarg1;
30015   arg2 = (float)jarg2;
30016   arg3 = (float)jarg3;
30017   {
30018     try {
30019       (arg1)->SetSize(arg2,arg3);
30020     } catch (std::out_of_range& e) {
30021       {
30022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30023       };
30024     } catch (std::exception& e) {
30025       {
30026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30027       };
30028     } catch (...) {
30029       {
30030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30031       };
30032     }
30033   }
30034 }
30035
30036
30037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30038   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30039   float arg2 ;
30040   float arg3 ;
30041   float arg4 ;
30042
30043   arg1 = (Dali::Actor *)jarg1;
30044   arg2 = (float)jarg2;
30045   arg3 = (float)jarg3;
30046   arg4 = (float)jarg4;
30047   {
30048     try {
30049       (arg1)->SetSize(arg2,arg3,arg4);
30050     } catch (std::out_of_range& e) {
30051       {
30052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30053       };
30054     } catch (std::exception& e) {
30055       {
30056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30057       };
30058     } catch (...) {
30059       {
30060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30061       };
30062     }
30063   }
30064 }
30065
30066
30067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
30068   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30069   Dali::Vector2 *arg2 = 0 ;
30070
30071   arg1 = (Dali::Actor *)jarg1;
30072   arg2 = (Dali::Vector2 *)jarg2;
30073   if (!arg2) {
30074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
30075     return ;
30076   }
30077   {
30078     try {
30079       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
30080     } catch (std::out_of_range& e) {
30081       {
30082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30083       };
30084     } catch (std::exception& e) {
30085       {
30086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30087       };
30088     } catch (...) {
30089       {
30090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30091       };
30092     }
30093   }
30094 }
30095
30096
30097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
30098   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30099   Dali::Vector3 *arg2 = 0 ;
30100
30101   arg1 = (Dali::Actor *)jarg1;
30102   arg2 = (Dali::Vector3 *)jarg2;
30103   if (!arg2) {
30104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30105     return ;
30106   }
30107   {
30108     try {
30109       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
30110     } catch (std::out_of_range& e) {
30111       {
30112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30113       };
30114     } catch (std::exception& e) {
30115       {
30116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30117       };
30118     } catch (...) {
30119       {
30120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30121       };
30122     }
30123   }
30124 }
30125
30126
30127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
30128   void * jresult ;
30129   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30130   Dali::Vector3 result;
30131
30132   arg1 = (Dali::Actor *)jarg1;
30133   {
30134     try {
30135       result = ((Dali::Actor const *)arg1)->GetTargetSize();
30136     } catch (std::out_of_range& e) {
30137       {
30138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30139       };
30140     } catch (std::exception& e) {
30141       {
30142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30143       };
30144     } catch (...) {
30145       {
30146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30147       };
30148     }
30149   }
30150   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30151   return jresult;
30152 }
30153
30154
30155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
30156   void * jresult ;
30157   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30158   Dali::Vector3 result;
30159
30160   arg1 = (Dali::Actor *)jarg1;
30161   {
30162     try {
30163       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
30164     } catch (std::out_of_range& e) {
30165       {
30166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30167       };
30168     } catch (std::exception& e) {
30169       {
30170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30171       };
30172     } catch (...) {
30173       {
30174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30175       };
30176     }
30177   }
30178   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30179   return jresult;
30180 }
30181
30182
30183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
30184   void * jresult ;
30185   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30186   Dali::Vector3 result;
30187
30188   arg1 = (Dali::Actor *)jarg1;
30189   {
30190     try {
30191       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
30192     } catch (std::out_of_range& e) {
30193       {
30194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30195       };
30196     } catch (std::exception& e) {
30197       {
30198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30199       };
30200     } catch (...) {
30201       {
30202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30203       };
30204     }
30205   }
30206   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30207   return jresult;
30208 }
30209
30210
30211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
30212   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30213   float arg2 ;
30214   float arg3 ;
30215
30216   arg1 = (Dali::Actor *)jarg1;
30217   arg2 = (float)jarg2;
30218   arg3 = (float)jarg3;
30219   {
30220     try {
30221       (arg1)->SetPosition(arg2,arg3);
30222     } catch (std::out_of_range& e) {
30223       {
30224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30225       };
30226     } catch (std::exception& e) {
30227       {
30228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30229       };
30230     } catch (...) {
30231       {
30232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30233       };
30234     }
30235   }
30236 }
30237
30238
30239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30240   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30241   float arg2 ;
30242   float arg3 ;
30243   float arg4 ;
30244
30245   arg1 = (Dali::Actor *)jarg1;
30246   arg2 = (float)jarg2;
30247   arg3 = (float)jarg3;
30248   arg4 = (float)jarg4;
30249   {
30250     try {
30251       (arg1)->SetPosition(arg2,arg3,arg4);
30252     } catch (std::out_of_range& e) {
30253       {
30254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30255       };
30256     } catch (std::exception& e) {
30257       {
30258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30259       };
30260     } catch (...) {
30261       {
30262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30263       };
30264     }
30265   }
30266 }
30267
30268
30269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
30270   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30271   Dali::Vector3 *arg2 = 0 ;
30272
30273   arg1 = (Dali::Actor *)jarg1;
30274   arg2 = (Dali::Vector3 *)jarg2;
30275   if (!arg2) {
30276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30277     return ;
30278   }
30279   {
30280     try {
30281       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
30282     } catch (std::out_of_range& e) {
30283       {
30284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30285       };
30286     } catch (std::exception& e) {
30287       {
30288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30289       };
30290     } catch (...) {
30291       {
30292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30293       };
30294     }
30295   }
30296 }
30297
30298
30299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
30300   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30301   float arg2 ;
30302
30303   arg1 = (Dali::Actor *)jarg1;
30304   arg2 = (float)jarg2;
30305   {
30306     try {
30307       (arg1)->SetX(arg2);
30308     } catch (std::out_of_range& e) {
30309       {
30310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30311       };
30312     } catch (std::exception& e) {
30313       {
30314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30315       };
30316     } catch (...) {
30317       {
30318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30319       };
30320     }
30321   }
30322 }
30323
30324
30325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
30326   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30327   float arg2 ;
30328
30329   arg1 = (Dali::Actor *)jarg1;
30330   arg2 = (float)jarg2;
30331   {
30332     try {
30333       (arg1)->SetY(arg2);
30334     } catch (std::out_of_range& e) {
30335       {
30336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30337       };
30338     } catch (std::exception& e) {
30339       {
30340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30341       };
30342     } catch (...) {
30343       {
30344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30345       };
30346     }
30347   }
30348 }
30349
30350
30351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
30352   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30353   float arg2 ;
30354
30355   arg1 = (Dali::Actor *)jarg1;
30356   arg2 = (float)jarg2;
30357   {
30358     try {
30359       (arg1)->SetZ(arg2);
30360     } catch (std::out_of_range& e) {
30361       {
30362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30363       };
30364     } catch (std::exception& e) {
30365       {
30366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30367       };
30368     } catch (...) {
30369       {
30370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30371       };
30372     }
30373   }
30374 }
30375
30376
30377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
30378   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30379   Dali::Vector3 *arg2 = 0 ;
30380
30381   arg1 = (Dali::Actor *)jarg1;
30382   arg2 = (Dali::Vector3 *)jarg2;
30383   if (!arg2) {
30384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30385     return ;
30386   }
30387   {
30388     try {
30389       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
30390     } catch (std::out_of_range& e) {
30391       {
30392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30393       };
30394     } catch (std::exception& e) {
30395       {
30396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30397       };
30398     } catch (...) {
30399       {
30400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30401       };
30402     }
30403   }
30404 }
30405
30406
30407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
30408   void * jresult ;
30409   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30410   Dali::Vector3 result;
30411
30412   arg1 = (Dali::Actor *)jarg1;
30413   {
30414     try {
30415       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
30416     } catch (std::out_of_range& e) {
30417       {
30418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30419       };
30420     } catch (std::exception& e) {
30421       {
30422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30423       };
30424     } catch (...) {
30425       {
30426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30427       };
30428     }
30429   }
30430   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30431   return jresult;
30432 }
30433
30434
30435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
30436   void * jresult ;
30437   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30438   Dali::Vector3 result;
30439
30440   arg1 = (Dali::Actor *)jarg1;
30441   {
30442     try {
30443       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
30444     } catch (std::out_of_range& e) {
30445       {
30446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30447       };
30448     } catch (std::exception& e) {
30449       {
30450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30451       };
30452     } catch (...) {
30453       {
30454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30455       };
30456     }
30457   }
30458   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30459   return jresult;
30460 }
30461
30462
30463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
30464   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30465   bool arg2 ;
30466
30467   arg1 = (Dali::Actor *)jarg1;
30468   arg2 = jarg2 ? true : false;
30469   {
30470     try {
30471       (arg1)->SetInheritPosition(arg2);
30472     } catch (std::out_of_range& e) {
30473       {
30474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30475       };
30476     } catch (std::exception& e) {
30477       {
30478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30479       };
30480     } catch (...) {
30481       {
30482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30483       };
30484     }
30485   }
30486 }
30487
30488
30489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetPositionInheritanceMode(void * jarg1) {
30490   int jresult ;
30491   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30492   Dali::PositionInheritanceMode result;
30493
30494   arg1 = (Dali::Actor *)jarg1;
30495   {
30496     try {
30497       result = (Dali::PositionInheritanceMode)((Dali::Actor const *)arg1)->GetPositionInheritanceMode();
30498     } catch (std::out_of_range& e) {
30499       {
30500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30501       };
30502     } catch (std::exception& e) {
30503       {
30504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30505       };
30506     } catch (...) {
30507       {
30508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30509       };
30510     }
30511   }
30512   jresult = (int)result;
30513   return jresult;
30514 }
30515
30516
30517 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
30518   unsigned int jresult ;
30519   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30520   bool result;
30521
30522   arg1 = (Dali::Actor *)jarg1;
30523   {
30524     try {
30525       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
30526     } catch (std::out_of_range& e) {
30527       {
30528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30529       };
30530     } catch (std::exception& e) {
30531       {
30532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30533       };
30534     } catch (...) {
30535       {
30536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30537       };
30538     }
30539   }
30540   jresult = result;
30541   return jresult;
30542 }
30543
30544
30545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30546   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30547   Dali::Degree *arg2 = 0 ;
30548   Dali::Vector3 *arg3 = 0 ;
30549
30550   arg1 = (Dali::Actor *)jarg1;
30551   arg2 = (Dali::Degree *)jarg2;
30552   if (!arg2) {
30553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30554     return ;
30555   }
30556   arg3 = (Dali::Vector3 *)jarg3;
30557   if (!arg3) {
30558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30559     return ;
30560   }
30561   {
30562     try {
30563       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30564     } catch (std::out_of_range& e) {
30565       {
30566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30567       };
30568     } catch (std::exception& e) {
30569       {
30570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30571       };
30572     } catch (...) {
30573       {
30574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30575       };
30576     }
30577   }
30578 }
30579
30580
30581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30582   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30583   Dali::Radian *arg2 = 0 ;
30584   Dali::Vector3 *arg3 = 0 ;
30585
30586   arg1 = (Dali::Actor *)jarg1;
30587   arg2 = (Dali::Radian *)jarg2;
30588   if (!arg2) {
30589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30590     return ;
30591   }
30592   arg3 = (Dali::Vector3 *)jarg3;
30593   if (!arg3) {
30594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30595     return ;
30596   }
30597   {
30598     try {
30599       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30600     } catch (std::out_of_range& e) {
30601       {
30602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30603       };
30604     } catch (std::exception& e) {
30605       {
30606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30607       };
30608     } catch (...) {
30609       {
30610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30611       };
30612     }
30613   }
30614 }
30615
30616
30617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
30618   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30619   Dali::Quaternion *arg2 = 0 ;
30620
30621   arg1 = (Dali::Actor *)jarg1;
30622   arg2 = (Dali::Quaternion *)jarg2;
30623   if (!arg2) {
30624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30625     return ;
30626   }
30627   {
30628     try {
30629       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
30630     } catch (std::out_of_range& e) {
30631       {
30632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30633       };
30634     } catch (std::exception& e) {
30635       {
30636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30637       };
30638     } catch (...) {
30639       {
30640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30641       };
30642     }
30643   }
30644 }
30645
30646
30647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30648   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30649   Dali::Degree *arg2 = 0 ;
30650   Dali::Vector3 *arg3 = 0 ;
30651
30652   arg1 = (Dali::Actor *)jarg1;
30653   arg2 = (Dali::Degree *)jarg2;
30654   if (!arg2) {
30655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30656     return ;
30657   }
30658   arg3 = (Dali::Vector3 *)jarg3;
30659   if (!arg3) {
30660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30661     return ;
30662   }
30663   {
30664     try {
30665       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30666     } catch (std::out_of_range& e) {
30667       {
30668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30669       };
30670     } catch (std::exception& e) {
30671       {
30672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30673       };
30674     } catch (...) {
30675       {
30676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30677       };
30678     }
30679   }
30680 }
30681
30682
30683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30684   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30685   Dali::Radian *arg2 = 0 ;
30686   Dali::Vector3 *arg3 = 0 ;
30687
30688   arg1 = (Dali::Actor *)jarg1;
30689   arg2 = (Dali::Radian *)jarg2;
30690   if (!arg2) {
30691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30692     return ;
30693   }
30694   arg3 = (Dali::Vector3 *)jarg3;
30695   if (!arg3) {
30696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30697     return ;
30698   }
30699   {
30700     try {
30701       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30702     } catch (std::out_of_range& e) {
30703       {
30704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30705       };
30706     } catch (std::exception& e) {
30707       {
30708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30709       };
30710     } catch (...) {
30711       {
30712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30713       };
30714     }
30715   }
30716 }
30717
30718
30719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
30720   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30721   Dali::Quaternion *arg2 = 0 ;
30722
30723   arg1 = (Dali::Actor *)jarg1;
30724   arg2 = (Dali::Quaternion *)jarg2;
30725   if (!arg2) {
30726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30727     return ;
30728   }
30729   {
30730     try {
30731       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
30732     } catch (std::out_of_range& e) {
30733       {
30734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30735       };
30736     } catch (std::exception& e) {
30737       {
30738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30739       };
30740     } catch (...) {
30741       {
30742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30743       };
30744     }
30745   }
30746 }
30747
30748
30749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
30750   void * jresult ;
30751   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30752   Dali::Quaternion result;
30753
30754   arg1 = (Dali::Actor *)jarg1;
30755   {
30756     try {
30757       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
30758     } catch (std::out_of_range& e) {
30759       {
30760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30761       };
30762     } catch (std::exception& e) {
30763       {
30764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30765       };
30766     } catch (...) {
30767       {
30768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30769       };
30770     }
30771   }
30772   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30773   return jresult;
30774 }
30775
30776
30777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
30778   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30779   bool arg2 ;
30780
30781   arg1 = (Dali::Actor *)jarg1;
30782   arg2 = jarg2 ? true : false;
30783   {
30784     try {
30785       (arg1)->SetInheritOrientation(arg2);
30786     } catch (std::out_of_range& e) {
30787       {
30788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30789       };
30790     } catch (std::exception& e) {
30791       {
30792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30793       };
30794     } catch (...) {
30795       {
30796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30797       };
30798     }
30799   }
30800 }
30801
30802
30803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
30804   unsigned int jresult ;
30805   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30806   bool result;
30807
30808   arg1 = (Dali::Actor *)jarg1;
30809   {
30810     try {
30811       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
30812     } catch (std::out_of_range& e) {
30813       {
30814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30815       };
30816     } catch (std::exception& e) {
30817       {
30818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30819       };
30820     } catch (...) {
30821       {
30822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30823       };
30824     }
30825   }
30826   jresult = result;
30827   return jresult;
30828 }
30829
30830
30831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
30832   void * jresult ;
30833   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30834   Dali::Quaternion result;
30835
30836   arg1 = (Dali::Actor *)jarg1;
30837   {
30838     try {
30839       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
30840     } catch (std::out_of_range& e) {
30841       {
30842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30843       };
30844     } catch (std::exception& e) {
30845       {
30846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30847       };
30848     } catch (...) {
30849       {
30850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30851       };
30852     }
30853   }
30854   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30855   return jresult;
30856 }
30857
30858
30859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
30860   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30861   float arg2 ;
30862
30863   arg1 = (Dali::Actor *)jarg1;
30864   arg2 = (float)jarg2;
30865   {
30866     try {
30867       (arg1)->SetScale(arg2);
30868     } catch (std::out_of_range& e) {
30869       {
30870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30871       };
30872     } catch (std::exception& e) {
30873       {
30874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30875       };
30876     } catch (...) {
30877       {
30878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30879       };
30880     }
30881   }
30882 }
30883
30884
30885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30886   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30887   float arg2 ;
30888   float arg3 ;
30889   float arg4 ;
30890
30891   arg1 = (Dali::Actor *)jarg1;
30892   arg2 = (float)jarg2;
30893   arg3 = (float)jarg3;
30894   arg4 = (float)jarg4;
30895   {
30896     try {
30897       (arg1)->SetScale(arg2,arg3,arg4);
30898     } catch (std::out_of_range& e) {
30899       {
30900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30901       };
30902     } catch (std::exception& e) {
30903       {
30904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30905       };
30906     } catch (...) {
30907       {
30908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30909       };
30910     }
30911   }
30912 }
30913
30914
30915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
30916   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30917   Dali::Vector3 *arg2 = 0 ;
30918
30919   arg1 = (Dali::Actor *)jarg1;
30920   arg2 = (Dali::Vector3 *)jarg2;
30921   if (!arg2) {
30922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30923     return ;
30924   }
30925   {
30926     try {
30927       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
30928     } catch (std::out_of_range& e) {
30929       {
30930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30931       };
30932     } catch (std::exception& e) {
30933       {
30934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30935       };
30936     } catch (...) {
30937       {
30938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30939       };
30940     }
30941   }
30942 }
30943
30944
30945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
30946   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30947   Dali::Vector3 *arg2 = 0 ;
30948
30949   arg1 = (Dali::Actor *)jarg1;
30950   arg2 = (Dali::Vector3 *)jarg2;
30951   if (!arg2) {
30952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30953     return ;
30954   }
30955   {
30956     try {
30957       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
30958     } catch (std::out_of_range& e) {
30959       {
30960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30961       };
30962     } catch (std::exception& e) {
30963       {
30964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30965       };
30966     } catch (...) {
30967       {
30968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30969       };
30970     }
30971   }
30972 }
30973
30974
30975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
30976   void * jresult ;
30977   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30978   Dali::Vector3 result;
30979
30980   arg1 = (Dali::Actor *)jarg1;
30981   {
30982     try {
30983       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
30984     } catch (std::out_of_range& e) {
30985       {
30986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30987       };
30988     } catch (std::exception& e) {
30989       {
30990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30991       };
30992     } catch (...) {
30993       {
30994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30995       };
30996     }
30997   }
30998   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30999   return jresult;
31000 }
31001
31002
31003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
31004   void * jresult ;
31005   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31006   Dali::Vector3 result;
31007
31008   arg1 = (Dali::Actor *)jarg1;
31009   {
31010     try {
31011       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
31012     } catch (std::out_of_range& e) {
31013       {
31014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31015       };
31016     } catch (std::exception& e) {
31017       {
31018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31019       };
31020     } catch (...) {
31021       {
31022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31023       };
31024     }
31025   }
31026   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31027   return jresult;
31028 }
31029
31030
31031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
31032   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31033   bool arg2 ;
31034
31035   arg1 = (Dali::Actor *)jarg1;
31036   arg2 = jarg2 ? true : false;
31037   {
31038     try {
31039       (arg1)->SetInheritScale(arg2);
31040     } catch (std::out_of_range& e) {
31041       {
31042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31043       };
31044     } catch (std::exception& e) {
31045       {
31046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31047       };
31048     } catch (...) {
31049       {
31050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31051       };
31052     }
31053   }
31054 }
31055
31056
31057 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
31058   unsigned int jresult ;
31059   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31060   bool result;
31061
31062   arg1 = (Dali::Actor *)jarg1;
31063   {
31064     try {
31065       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
31066     } catch (std::out_of_range& e) {
31067       {
31068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31069       };
31070     } catch (std::exception& e) {
31071       {
31072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31073       };
31074     } catch (...) {
31075       {
31076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31077       };
31078     }
31079   }
31080   jresult = result;
31081   return jresult;
31082 }
31083
31084
31085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
31086   void * jresult ;
31087   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31088   Dali::Matrix result;
31089
31090   arg1 = (Dali::Actor *)jarg1;
31091   {
31092     try {
31093       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
31094     } catch (std::out_of_range& e) {
31095       {
31096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31097       };
31098     } catch (std::exception& e) {
31099       {
31100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31101       };
31102     } catch (...) {
31103       {
31104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31105       };
31106     }
31107   }
31108   jresult = new Dali::Matrix((const Dali::Matrix &)result);
31109   return jresult;
31110 }
31111
31112
31113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
31114   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31115   bool arg2 ;
31116
31117   arg1 = (Dali::Actor *)jarg1;
31118   arg2 = jarg2 ? true : false;
31119   {
31120     try {
31121       (arg1)->SetVisible(arg2);
31122     } catch (std::out_of_range& e) {
31123       {
31124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31125       };
31126     } catch (std::exception& e) {
31127       {
31128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31129       };
31130     } catch (...) {
31131       {
31132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31133       };
31134     }
31135   }
31136 }
31137
31138
31139 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
31140   unsigned int jresult ;
31141   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31142   bool result;
31143
31144   arg1 = (Dali::Actor *)jarg1;
31145   {
31146     try {
31147       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
31148     } catch (std::out_of_range& e) {
31149       {
31150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31151       };
31152     } catch (std::exception& e) {
31153       {
31154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31155       };
31156     } catch (...) {
31157       {
31158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31159       };
31160     }
31161   }
31162   jresult = result;
31163   return jresult;
31164 }
31165
31166
31167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
31168   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31169   float arg2 ;
31170
31171   arg1 = (Dali::Actor *)jarg1;
31172   arg2 = (float)jarg2;
31173   {
31174     try {
31175       (arg1)->SetOpacity(arg2);
31176     } catch (std::out_of_range& e) {
31177       {
31178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31179       };
31180     } catch (std::exception& e) {
31181       {
31182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31183       };
31184     } catch (...) {
31185       {
31186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31187       };
31188     }
31189   }
31190 }
31191
31192
31193 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
31194   float jresult ;
31195   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31196   float result;
31197
31198   arg1 = (Dali::Actor *)jarg1;
31199   {
31200     try {
31201       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
31202     } catch (std::out_of_range& e) {
31203       {
31204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31205       };
31206     } catch (std::exception& e) {
31207       {
31208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31209       };
31210     } catch (...) {
31211       {
31212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31213       };
31214     }
31215   }
31216   jresult = result;
31217   return jresult;
31218 }
31219
31220
31221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
31222   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31223   Dali::Vector4 *arg2 = 0 ;
31224
31225   arg1 = (Dali::Actor *)jarg1;
31226   arg2 = (Dali::Vector4 *)jarg2;
31227   if (!arg2) {
31228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
31229     return ;
31230   }
31231   {
31232     try {
31233       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
31234     } catch (std::out_of_range& e) {
31235       {
31236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31237       };
31238     } catch (std::exception& e) {
31239       {
31240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31241       };
31242     } catch (...) {
31243       {
31244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31245       };
31246     }
31247   }
31248 }
31249
31250
31251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
31252   void * jresult ;
31253   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31254   Dali::Vector4 result;
31255
31256   arg1 = (Dali::Actor *)jarg1;
31257   {
31258     try {
31259       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
31260     } catch (std::out_of_range& e) {
31261       {
31262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31263       };
31264     } catch (std::exception& e) {
31265       {
31266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31267       };
31268     } catch (...) {
31269       {
31270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31271       };
31272     }
31273   }
31274   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31275   return jresult;
31276 }
31277
31278
31279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
31280   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31281   Dali::ColorMode arg2 ;
31282
31283   arg1 = (Dali::Actor *)jarg1;
31284   arg2 = (Dali::ColorMode)jarg2;
31285   {
31286     try {
31287       (arg1)->SetColorMode(arg2);
31288     } catch (std::out_of_range& e) {
31289       {
31290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31291       };
31292     } catch (std::exception& e) {
31293       {
31294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31295       };
31296     } catch (...) {
31297       {
31298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31299       };
31300     }
31301   }
31302 }
31303
31304
31305 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
31306   int jresult ;
31307   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31308   Dali::ColorMode result;
31309
31310   arg1 = (Dali::Actor *)jarg1;
31311   {
31312     try {
31313       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
31314     } catch (std::out_of_range& e) {
31315       {
31316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31317       };
31318     } catch (std::exception& e) {
31319       {
31320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31321       };
31322     } catch (...) {
31323       {
31324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31325       };
31326     }
31327   }
31328   jresult = (int)result;
31329   return jresult;
31330 }
31331
31332
31333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
31334   void * jresult ;
31335   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31336   Dali::Vector4 result;
31337
31338   arg1 = (Dali::Actor *)jarg1;
31339   {
31340     try {
31341       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
31342     } catch (std::out_of_range& e) {
31343       {
31344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31345       };
31346     } catch (std::exception& e) {
31347       {
31348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31349       };
31350     } catch (...) {
31351       {
31352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31353       };
31354     }
31355   }
31356   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31357   return jresult;
31358 }
31359
31360
31361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
31362   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31363   Dali::DrawMode::Type arg2 ;
31364
31365   arg1 = (Dali::Actor *)jarg1;
31366   arg2 = (Dali::DrawMode::Type)jarg2;
31367   {
31368     try {
31369       (arg1)->SetDrawMode(arg2);
31370     } catch (std::out_of_range& e) {
31371       {
31372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31373       };
31374     } catch (std::exception& e) {
31375       {
31376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31377       };
31378     } catch (...) {
31379       {
31380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31381       };
31382     }
31383   }
31384 }
31385
31386
31387 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
31388   int jresult ;
31389   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31390   Dali::DrawMode::Type result;
31391
31392   arg1 = (Dali::Actor *)jarg1;
31393   {
31394     try {
31395       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
31396     } catch (std::out_of_range& e) {
31397       {
31398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31399       };
31400     } catch (std::exception& e) {
31401       {
31402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31403       };
31404     } catch (...) {
31405       {
31406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31407       };
31408     }
31409   }
31410   jresult = (int)result;
31411   return jresult;
31412 }
31413
31414
31415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
31416   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31417   bool arg2 ;
31418
31419   arg1 = (Dali::Actor *)jarg1;
31420   arg2 = jarg2 ? true : false;
31421   {
31422     try {
31423       (arg1)->SetSensitive(arg2);
31424     } catch (std::out_of_range& e) {
31425       {
31426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31427       };
31428     } catch (std::exception& e) {
31429       {
31430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31431       };
31432     } catch (...) {
31433       {
31434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31435       };
31436     }
31437   }
31438 }
31439
31440
31441 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
31442   unsigned int jresult ;
31443   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31444   bool result;
31445
31446   arg1 = (Dali::Actor *)jarg1;
31447   {
31448     try {
31449       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
31450     } catch (std::out_of_range& e) {
31451       {
31452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31453       };
31454     } catch (std::exception& e) {
31455       {
31456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31457       };
31458     } catch (...) {
31459       {
31460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31461       };
31462     }
31463   }
31464   jresult = result;
31465   return jresult;
31466 }
31467
31468
31469 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
31470   unsigned int jresult ;
31471   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31472   float *arg2 = 0 ;
31473   float *arg3 = 0 ;
31474   float arg4 ;
31475   float arg5 ;
31476   bool result;
31477
31478   arg1 = (Dali::Actor *)jarg1;
31479   arg2 = (float *)jarg2;
31480   arg3 = (float *)jarg3;
31481   arg4 = (float)jarg4;
31482   arg5 = (float)jarg5;
31483   {
31484     try {
31485       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
31486     } catch (std::out_of_range& e) {
31487       {
31488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31489       };
31490     } catch (std::exception& e) {
31491       {
31492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31493       };
31494     } catch (...) {
31495       {
31496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31497       };
31498     }
31499   }
31500   jresult = result;
31501   return jresult;
31502 }
31503
31504
31505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
31506   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31507   bool arg2 ;
31508
31509   arg1 = (Dali::Actor *)jarg1;
31510   arg2 = jarg2 ? true : false;
31511   {
31512     try {
31513       (arg1)->SetLeaveRequired(arg2);
31514     } catch (std::out_of_range& e) {
31515       {
31516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31517       };
31518     } catch (std::exception& e) {
31519       {
31520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31521       };
31522     } catch (...) {
31523       {
31524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31525       };
31526     }
31527   }
31528 }
31529
31530
31531 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
31532   unsigned int jresult ;
31533   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31534   bool result;
31535
31536   arg1 = (Dali::Actor *)jarg1;
31537   {
31538     try {
31539       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
31540     } catch (std::out_of_range& e) {
31541       {
31542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31543       };
31544     } catch (std::exception& e) {
31545       {
31546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31547       };
31548     } catch (...) {
31549       {
31550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31551       };
31552     }
31553   }
31554   jresult = result;
31555   return jresult;
31556 }
31557
31558
31559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
31560   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31561   bool arg2 ;
31562
31563   arg1 = (Dali::Actor *)jarg1;
31564   arg2 = jarg2 ? true : false;
31565   {
31566     try {
31567       (arg1)->SetKeyboardFocusable(arg2);
31568     } catch (std::out_of_range& e) {
31569       {
31570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31571       };
31572     } catch (std::exception& e) {
31573       {
31574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31575       };
31576     } catch (...) {
31577       {
31578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31579       };
31580     }
31581   }
31582 }
31583
31584
31585 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
31586   unsigned int jresult ;
31587   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31588   bool result;
31589
31590   arg1 = (Dali::Actor *)jarg1;
31591   {
31592     try {
31593       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
31594     } catch (std::out_of_range& e) {
31595       {
31596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31597       };
31598     } catch (std::exception& e) {
31599       {
31600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31601       };
31602     } catch (...) {
31603       {
31604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31605       };
31606     }
31607   }
31608   jresult = result;
31609   return jresult;
31610 }
31611
31612
31613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
31614   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31615   Dali::ResizePolicy::Type arg2 ;
31616   Dali::Dimension::Type arg3 ;
31617
31618   arg1 = (Dali::Actor *)jarg1;
31619   arg2 = (Dali::ResizePolicy::Type)jarg2;
31620   arg3 = (Dali::Dimension::Type)jarg3;
31621   {
31622     try {
31623       (arg1)->SetResizePolicy(arg2,arg3);
31624     } catch (std::out_of_range& e) {
31625       {
31626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31627       };
31628     } catch (std::exception& e) {
31629       {
31630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31631       };
31632     } catch (...) {
31633       {
31634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31635       };
31636     }
31637   }
31638 }
31639
31640
31641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
31642   int jresult ;
31643   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31644   Dali::Dimension::Type arg2 ;
31645   Dali::ResizePolicy::Type result;
31646
31647   arg1 = (Dali::Actor *)jarg1;
31648   arg2 = (Dali::Dimension::Type)jarg2;
31649   {
31650     try {
31651       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
31652     } catch (std::out_of_range& e) {
31653       {
31654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31655       };
31656     } catch (std::exception& e) {
31657       {
31658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31659       };
31660     } catch (...) {
31661       {
31662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31663       };
31664     }
31665   }
31666   jresult = (int)result;
31667   return jresult;
31668 }
31669
31670
31671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
31672   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31673   Dali::SizeScalePolicy::Type arg2 ;
31674
31675   arg1 = (Dali::Actor *)jarg1;
31676   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
31677   {
31678     try {
31679       (arg1)->SetSizeScalePolicy(arg2);
31680     } catch (std::out_of_range& e) {
31681       {
31682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31683       };
31684     } catch (std::exception& e) {
31685       {
31686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31687       };
31688     } catch (...) {
31689       {
31690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31691       };
31692     }
31693   }
31694 }
31695
31696
31697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
31698   int jresult ;
31699   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31700   Dali::SizeScalePolicy::Type result;
31701
31702   arg1 = (Dali::Actor *)jarg1;
31703   {
31704     try {
31705       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
31706     } catch (std::out_of_range& e) {
31707       {
31708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31709       };
31710     } catch (std::exception& e) {
31711       {
31712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31713       };
31714     } catch (...) {
31715       {
31716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31717       };
31718     }
31719   }
31720   jresult = (int)result;
31721   return jresult;
31722 }
31723
31724
31725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
31726   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31727   Dali::Vector3 *arg2 = 0 ;
31728
31729   arg1 = (Dali::Actor *)jarg1;
31730   arg2 = (Dali::Vector3 *)jarg2;
31731   if (!arg2) {
31732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
31733     return ;
31734   }
31735   {
31736     try {
31737       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
31738     } catch (std::out_of_range& e) {
31739       {
31740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31741       };
31742     } catch (std::exception& e) {
31743       {
31744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31745       };
31746     } catch (...) {
31747       {
31748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31749       };
31750     }
31751   }
31752 }
31753
31754
31755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
31756   void * jresult ;
31757   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31758   Dali::Vector3 result;
31759
31760   arg1 = (Dali::Actor *)jarg1;
31761   {
31762     try {
31763       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
31764     } catch (std::out_of_range& e) {
31765       {
31766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31767       };
31768     } catch (std::exception& e) {
31769       {
31770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31771       };
31772     } catch (...) {
31773       {
31774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31775       };
31776     }
31777   }
31778   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31779   return jresult;
31780 }
31781
31782
31783 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
31784   float jresult ;
31785   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31786   float arg2 ;
31787   float result;
31788
31789   arg1 = (Dali::Actor *)jarg1;
31790   arg2 = (float)jarg2;
31791   {
31792     try {
31793       result = (float)(arg1)->GetHeightForWidth(arg2);
31794     } catch (std::out_of_range& e) {
31795       {
31796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31797       };
31798     } catch (std::exception& e) {
31799       {
31800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31801       };
31802     } catch (...) {
31803       {
31804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31805       };
31806     }
31807   }
31808   jresult = result;
31809   return jresult;
31810 }
31811
31812
31813 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
31814   float jresult ;
31815   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31816   float arg2 ;
31817   float result;
31818
31819   arg1 = (Dali::Actor *)jarg1;
31820   arg2 = (float)jarg2;
31821   {
31822     try {
31823       result = (float)(arg1)->GetWidthForHeight(arg2);
31824     } catch (std::out_of_range& e) {
31825       {
31826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31827       };
31828     } catch (std::exception& e) {
31829       {
31830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31831       };
31832     } catch (...) {
31833       {
31834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31835       };
31836     }
31837   }
31838   jresult = result;
31839   return jresult;
31840 }
31841
31842
31843 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
31844   float jresult ;
31845   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31846   Dali::Dimension::Type arg2 ;
31847   float result;
31848
31849   arg1 = (Dali::Actor *)jarg1;
31850   arg2 = (Dali::Dimension::Type)jarg2;
31851   {
31852     try {
31853       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
31854     } catch (std::out_of_range& e) {
31855       {
31856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31857       };
31858     } catch (std::exception& e) {
31859       {
31860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31861       };
31862     } catch (...) {
31863       {
31864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31865       };
31866     }
31867   }
31868   jresult = result;
31869   return jresult;
31870 }
31871
31872
31873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
31874   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31875   Dali::Padding *arg2 = 0 ;
31876
31877   arg1 = (Dali::Actor *)jarg1;
31878   arg2 = (Dali::Padding *)jarg2;
31879   if (!arg2) {
31880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
31881     return ;
31882   }
31883   {
31884     try {
31885       (arg1)->SetPadding((Dali::Padding const &)*arg2);
31886     } catch (std::out_of_range& e) {
31887       {
31888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31889       };
31890     } catch (std::exception& e) {
31891       {
31892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31893       };
31894     } catch (...) {
31895       {
31896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31897       };
31898     }
31899   }
31900 }
31901
31902
31903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
31904   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31905   Dali::Padding *arg2 = 0 ;
31906
31907   arg1 = (Dali::Actor *)jarg1;
31908   arg2 = (Dali::Padding *)jarg2;
31909   if (!arg2) {
31910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
31911     return ;
31912   }
31913   {
31914     try {
31915       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
31916     } catch (std::out_of_range& e) {
31917       {
31918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31919       };
31920     } catch (std::exception& e) {
31921       {
31922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31923       };
31924     } catch (...) {
31925       {
31926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31927       };
31928     }
31929   }
31930 }
31931
31932
31933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
31934   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31935   Dali::Vector2 *arg2 = 0 ;
31936
31937   arg1 = (Dali::Actor *)jarg1;
31938   arg2 = (Dali::Vector2 *)jarg2;
31939   if (!arg2) {
31940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
31941     return ;
31942   }
31943   {
31944     try {
31945       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
31946     } catch (std::out_of_range& e) {
31947       {
31948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31949       };
31950     } catch (std::exception& e) {
31951       {
31952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31953       };
31954     } catch (...) {
31955       {
31956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31957       };
31958     }
31959   }
31960 }
31961
31962
31963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
31964   void * jresult ;
31965   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31966   Dali::Vector2 result;
31967
31968   arg1 = (Dali::Actor *)jarg1;
31969   {
31970     try {
31971       result = (arg1)->GetMinimumSize();
31972     } catch (std::out_of_range& e) {
31973       {
31974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31975       };
31976     } catch (std::exception& e) {
31977       {
31978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31979       };
31980     } catch (...) {
31981       {
31982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31983       };
31984     }
31985   }
31986   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
31987   return jresult;
31988 }
31989
31990
31991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
31992   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31993   Dali::Vector2 *arg2 = 0 ;
31994
31995   arg1 = (Dali::Actor *)jarg1;
31996   arg2 = (Dali::Vector2 *)jarg2;
31997   if (!arg2) {
31998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
31999     return ;
32000   }
32001   {
32002     try {
32003       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
32004     } catch (std::out_of_range& e) {
32005       {
32006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32007       };
32008     } catch (std::exception& e) {
32009       {
32010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32011       };
32012     } catch (...) {
32013       {
32014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32015       };
32016     }
32017   }
32018 }
32019
32020
32021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
32022   void * jresult ;
32023   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32024   Dali::Vector2 result;
32025
32026   arg1 = (Dali::Actor *)jarg1;
32027   {
32028     try {
32029       result = (arg1)->GetMaximumSize();
32030     } catch (std::out_of_range& e) {
32031       {
32032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32033       };
32034     } catch (std::exception& e) {
32035       {
32036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32037       };
32038     } catch (...) {
32039       {
32040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32041       };
32042     }
32043   }
32044   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
32045   return jresult;
32046 }
32047
32048
32049 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
32050   int jresult ;
32051   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32052   int result;
32053
32054   arg1 = (Dali::Actor *)jarg1;
32055   {
32056     try {
32057       result = (int)(arg1)->GetHierarchyDepth();
32058     } catch (std::out_of_range& e) {
32059       {
32060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32061       };
32062     } catch (std::exception& e) {
32063       {
32064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32065       };
32066     } catch (...) {
32067       {
32068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32069       };
32070     }
32071   }
32072   jresult = result;
32073   return jresult;
32074 }
32075
32076
32077 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
32078   unsigned int jresult ;
32079   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32080   Dali::Renderer *arg2 = 0 ;
32081   unsigned int result;
32082
32083   arg1 = (Dali::Actor *)jarg1;
32084   arg2 = (Dali::Renderer *)jarg2;
32085   if (!arg2) {
32086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
32087     return 0;
32088   }
32089   {
32090     try {
32091       result = (unsigned int)(arg1)->AddRenderer(*arg2);
32092     } catch (std::out_of_range& e) {
32093       {
32094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32095       };
32096     } catch (std::exception& e) {
32097       {
32098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32099       };
32100     } catch (...) {
32101       {
32102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32103       };
32104     }
32105   }
32106   jresult = result;
32107   return jresult;
32108 }
32109
32110
32111 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
32112   unsigned int jresult ;
32113   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32114   unsigned int result;
32115
32116   arg1 = (Dali::Actor *)jarg1;
32117   {
32118     try {
32119       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
32120     } catch (std::out_of_range& e) {
32121       {
32122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32123       };
32124     } catch (std::exception& e) {
32125       {
32126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32127       };
32128     } catch (...) {
32129       {
32130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32131       };
32132     }
32133   }
32134   jresult = result;
32135   return jresult;
32136 }
32137
32138
32139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
32140   void * jresult ;
32141   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32142   unsigned int arg2 ;
32143   Dali::Renderer result;
32144
32145   arg1 = (Dali::Actor *)jarg1;
32146   arg2 = (unsigned int)jarg2;
32147   {
32148     try {
32149       result = (arg1)->GetRendererAt(arg2);
32150     } catch (std::out_of_range& e) {
32151       {
32152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32153       };
32154     } catch (std::exception& e) {
32155       {
32156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32157       };
32158     } catch (...) {
32159       {
32160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32161       };
32162     }
32163   }
32164   jresult = new Dali::Renderer((const Dali::Renderer &)result);
32165   return jresult;
32166 }
32167
32168
32169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
32170   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32171   Dali::Renderer *arg2 = 0 ;
32172
32173   arg1 = (Dali::Actor *)jarg1;
32174   arg2 = (Dali::Renderer *)jarg2;
32175   if (!arg2) {
32176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
32177     return ;
32178   }
32179   {
32180     try {
32181       (arg1)->RemoveRenderer(*arg2);
32182     } catch (std::out_of_range& e) {
32183       {
32184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32185       };
32186     } catch (std::exception& e) {
32187       {
32188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32189       };
32190     } catch (...) {
32191       {
32192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32193       };
32194     }
32195   }
32196 }
32197
32198
32199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
32200   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32201   unsigned int arg2 ;
32202
32203   arg1 = (Dali::Actor *)jarg1;
32204   arg2 = (unsigned int)jarg2;
32205   {
32206     try {
32207       (arg1)->RemoveRenderer(arg2);
32208     } catch (std::out_of_range& e) {
32209       {
32210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32211       };
32212     } catch (std::exception& e) {
32213       {
32214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32215       };
32216     } catch (...) {
32217       {
32218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32219       };
32220     }
32221   }
32222 }
32223
32224
32225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
32226   void * jresult ;
32227   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32228   Dali::Actor::TouchSignalType *result = 0 ;
32229
32230   arg1 = (Dali::Actor *)jarg1;
32231   {
32232     try {
32233       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
32234     } catch (std::out_of_range& e) {
32235       {
32236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32237       };
32238     } catch (std::exception& e) {
32239       {
32240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32241       };
32242     } catch (...) {
32243       {
32244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32245       };
32246     }
32247   }
32248   jresult = (void *)result;
32249   return jresult;
32250 }
32251
32252
32253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
32254   void * jresult ;
32255   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32256   Dali::Actor::TouchDataSignalType *result = 0 ;
32257
32258   arg1 = (Dali::Actor *)jarg1;
32259   {
32260     try {
32261       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
32262     } catch (std::out_of_range& e) {
32263       {
32264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32265       };
32266     } catch (std::exception& e) {
32267       {
32268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32269       };
32270     } catch (...) {
32271       {
32272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32273       };
32274     }
32275   }
32276   jresult = (void *)result;
32277   return jresult;
32278 }
32279
32280
32281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
32282   void * jresult ;
32283   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32284   Dali::Actor::HoverSignalType *result = 0 ;
32285
32286   arg1 = (Dali::Actor *)jarg1;
32287   {
32288     try {
32289       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
32290     } catch (std::out_of_range& e) {
32291       {
32292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32293       };
32294     } catch (std::exception& e) {
32295       {
32296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32297       };
32298     } catch (...) {
32299       {
32300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32301       };
32302     }
32303   }
32304   jresult = (void *)result;
32305   return jresult;
32306 }
32307
32308
32309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
32310   void * jresult ;
32311   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32312   Dali::Actor::WheelEventSignalType *result = 0 ;
32313
32314   arg1 = (Dali::Actor *)jarg1;
32315   {
32316     try {
32317       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
32318     } catch (std::out_of_range& e) {
32319       {
32320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32321       };
32322     } catch (std::exception& e) {
32323       {
32324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32325       };
32326     } catch (...) {
32327       {
32328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32329       };
32330     }
32331   }
32332   jresult = (void *)result;
32333   return jresult;
32334 }
32335
32336
32337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
32338   void * jresult ;
32339   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32340   Dali::Actor::OnStageSignalType *result = 0 ;
32341
32342   arg1 = (Dali::Actor *)jarg1;
32343   {
32344     try {
32345       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
32346     } catch (std::out_of_range& e) {
32347       {
32348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32349       };
32350     } catch (std::exception& e) {
32351       {
32352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32353       };
32354     } catch (...) {
32355       {
32356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32357       };
32358     }
32359   }
32360   jresult = (void *)result;
32361   return jresult;
32362 }
32363
32364
32365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
32366   void * jresult ;
32367   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32368   Dali::Actor::OffStageSignalType *result = 0 ;
32369
32370   arg1 = (Dali::Actor *)jarg1;
32371   {
32372     try {
32373       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
32374     } catch (std::out_of_range& e) {
32375       {
32376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32377       };
32378     } catch (std::exception& e) {
32379       {
32380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32381       };
32382     } catch (...) {
32383       {
32384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32385       };
32386     }
32387   }
32388   jresult = (void *)result;
32389   return jresult;
32390 }
32391
32392
32393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
32394   void * jresult ;
32395   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32396   Dali::Actor::OnRelayoutSignalType *result = 0 ;
32397
32398   arg1 = (Dali::Actor *)jarg1;
32399   {
32400     try {
32401       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
32402     } catch (std::out_of_range& e) {
32403       {
32404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32405       };
32406     } catch (std::exception& e) {
32407       {
32408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32409       };
32410     } catch (...) {
32411       {
32412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32413       };
32414     }
32415   }
32416   jresult = (void *)result;
32417   return jresult;
32418 }
32419
32420
32421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
32422   Dali::Actor *arg1 = 0 ;
32423
32424   arg1 = (Dali::Actor *)jarg1;
32425   if (!arg1) {
32426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
32427     return ;
32428   }
32429   {
32430     try {
32431       Dali::UnparentAndReset(*arg1);
32432     } catch (std::out_of_range& e) {
32433       {
32434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32435       };
32436     } catch (std::exception& e) {
32437       {
32438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32439       };
32440     } catch (...) {
32441       {
32442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32443       };
32444     }
32445   }
32446 }
32447
32448
32449 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
32450   int jresult ;
32451   int result;
32452
32453   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
32454   jresult = (int)result;
32455   return jresult;
32456 }
32457
32458
32459 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
32460   int jresult ;
32461   int result;
32462
32463   result = (int)Dali::Layer::Property::CLIPPING_BOX;
32464   jresult = (int)result;
32465   return jresult;
32466 }
32467
32468
32469 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
32470   int jresult ;
32471   int result;
32472
32473   result = (int)Dali::Layer::Property::BEHAVIOR;
32474   jresult = (int)result;
32475   return jresult;
32476 }
32477
32478
32479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
32480   void * jresult ;
32481   Dali::Layer::Property *result = 0 ;
32482
32483   {
32484     try {
32485       result = (Dali::Layer::Property *)new Dali::Layer::Property();
32486     } catch (std::out_of_range& e) {
32487       {
32488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32489       };
32490     } catch (std::exception& e) {
32491       {
32492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32493       };
32494     } catch (...) {
32495       {
32496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32497       };
32498     }
32499   }
32500   jresult = (void *)result;
32501   return jresult;
32502 }
32503
32504
32505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
32506   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
32507
32508   arg1 = (Dali::Layer::Property *)jarg1;
32509   {
32510     try {
32511       delete arg1;
32512     } catch (std::out_of_range& e) {
32513       {
32514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32515       };
32516     } catch (std::exception& e) {
32517       {
32518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32519       };
32520     } catch (...) {
32521       {
32522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32523       };
32524     }
32525   }
32526 }
32527
32528
32529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
32530   void * jresult ;
32531   Dali::Layer *result = 0 ;
32532
32533   {
32534     try {
32535       result = (Dali::Layer *)new Dali::Layer();
32536     } catch (std::out_of_range& e) {
32537       {
32538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32539       };
32540     } catch (std::exception& e) {
32541       {
32542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32543       };
32544     } catch (...) {
32545       {
32546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32547       };
32548     }
32549   }
32550   jresult = (void *)result;
32551   return jresult;
32552 }
32553
32554
32555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
32556   void * jresult ;
32557   Dali::Layer result;
32558
32559   {
32560     try {
32561       result = Dali::Layer::New();
32562     } catch (std::out_of_range& e) {
32563       {
32564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32565       };
32566     } catch (std::exception& e) {
32567       {
32568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32569       };
32570     } catch (...) {
32571       {
32572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32573       };
32574     }
32575   }
32576   jresult = new Dali::Layer((const Dali::Layer &)result);
32577   return jresult;
32578 }
32579
32580
32581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
32582   void * jresult ;
32583   Dali::BaseHandle arg1 ;
32584   Dali::BaseHandle *argp1 ;
32585   Dali::Layer result;
32586
32587   argp1 = (Dali::BaseHandle *)jarg1;
32588   if (!argp1) {
32589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
32590     return 0;
32591   }
32592   arg1 = *argp1;
32593   {
32594     try {
32595       result = Dali::Layer::DownCast(arg1);
32596     } catch (std::out_of_range& e) {
32597       {
32598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32599       };
32600     } catch (std::exception& e) {
32601       {
32602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32603       };
32604     } catch (...) {
32605       {
32606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32607       };
32608     }
32609   }
32610   jresult = new Dali::Layer((const Dali::Layer &)result);
32611   return jresult;
32612 }
32613
32614
32615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
32616   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32617
32618   arg1 = (Dali::Layer *)jarg1;
32619   {
32620     try {
32621       delete arg1;
32622     } catch (std::out_of_range& e) {
32623       {
32624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32625       };
32626     } catch (std::exception& e) {
32627       {
32628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32629       };
32630     } catch (...) {
32631       {
32632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32633       };
32634     }
32635   }
32636 }
32637
32638
32639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
32640   void * jresult ;
32641   Dali::Layer *arg1 = 0 ;
32642   Dali::Layer *result = 0 ;
32643
32644   arg1 = (Dali::Layer *)jarg1;
32645   if (!arg1) {
32646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32647     return 0;
32648   }
32649   {
32650     try {
32651       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
32652     } catch (std::out_of_range& e) {
32653       {
32654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32655       };
32656     } catch (std::exception& e) {
32657       {
32658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32659       };
32660     } catch (...) {
32661       {
32662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32663       };
32664     }
32665   }
32666   jresult = (void *)result;
32667   return jresult;
32668 }
32669
32670
32671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
32672   void * jresult ;
32673   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32674   Dali::Layer *arg2 = 0 ;
32675   Dali::Layer *result = 0 ;
32676
32677   arg1 = (Dali::Layer *)jarg1;
32678   arg2 = (Dali::Layer *)jarg2;
32679   if (!arg2) {
32680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32681     return 0;
32682   }
32683   {
32684     try {
32685       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
32686     } catch (std::out_of_range& e) {
32687       {
32688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32689       };
32690     } catch (std::exception& e) {
32691       {
32692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32693       };
32694     } catch (...) {
32695       {
32696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32697       };
32698     }
32699   }
32700   jresult = (void *)result;
32701   return jresult;
32702 }
32703
32704
32705 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
32706   unsigned int jresult ;
32707   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32708   unsigned int result;
32709
32710   arg1 = (Dali::Layer *)jarg1;
32711   {
32712     try {
32713       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
32714     } catch (std::out_of_range& e) {
32715       {
32716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32717       };
32718     } catch (std::exception& e) {
32719       {
32720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32721       };
32722     } catch (...) {
32723       {
32724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32725       };
32726     }
32727   }
32728   jresult = result;
32729   return jresult;
32730 }
32731
32732
32733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
32734   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32735
32736   arg1 = (Dali::Layer *)jarg1;
32737   {
32738     try {
32739       (arg1)->Raise();
32740     } catch (std::out_of_range& e) {
32741       {
32742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32743       };
32744     } catch (std::exception& e) {
32745       {
32746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32747       };
32748     } catch (...) {
32749       {
32750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32751       };
32752     }
32753   }
32754 }
32755
32756
32757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
32758   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32759
32760   arg1 = (Dali::Layer *)jarg1;
32761   {
32762     try {
32763       (arg1)->Lower();
32764     } catch (std::out_of_range& e) {
32765       {
32766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32767       };
32768     } catch (std::exception& e) {
32769       {
32770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32771       };
32772     } catch (...) {
32773       {
32774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32775       };
32776     }
32777   }
32778 }
32779
32780
32781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
32782   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32783   Dali::Layer arg2 ;
32784   Dali::Layer *argp2 ;
32785
32786   arg1 = (Dali::Layer *)jarg1;
32787   argp2 = (Dali::Layer *)jarg2;
32788   if (!argp2) {
32789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32790     return ;
32791   }
32792   arg2 = *argp2;
32793   {
32794     try {
32795       (arg1)->RaiseAbove(arg2);
32796     } catch (std::out_of_range& e) {
32797       {
32798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32799       };
32800     } catch (std::exception& e) {
32801       {
32802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32803       };
32804     } catch (...) {
32805       {
32806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32807       };
32808     }
32809   }
32810 }
32811
32812
32813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
32814   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32815   Dali::Layer arg2 ;
32816   Dali::Layer *argp2 ;
32817
32818   arg1 = (Dali::Layer *)jarg1;
32819   argp2 = (Dali::Layer *)jarg2;
32820   if (!argp2) {
32821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32822     return ;
32823   }
32824   arg2 = *argp2;
32825   {
32826     try {
32827       (arg1)->LowerBelow(arg2);
32828     } catch (std::out_of_range& e) {
32829       {
32830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32831       };
32832     } catch (std::exception& e) {
32833       {
32834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32835       };
32836     } catch (...) {
32837       {
32838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32839       };
32840     }
32841   }
32842 }
32843
32844
32845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
32846   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32847
32848   arg1 = (Dali::Layer *)jarg1;
32849   {
32850     try {
32851       (arg1)->RaiseToTop();
32852     } catch (std::out_of_range& e) {
32853       {
32854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32855       };
32856     } catch (std::exception& e) {
32857       {
32858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32859       };
32860     } catch (...) {
32861       {
32862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32863       };
32864     }
32865   }
32866 }
32867
32868
32869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
32870   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32871
32872   arg1 = (Dali::Layer *)jarg1;
32873   {
32874     try {
32875       (arg1)->LowerToBottom();
32876     } catch (std::out_of_range& e) {
32877       {
32878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32879       };
32880     } catch (std::exception& e) {
32881       {
32882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32883       };
32884     } catch (...) {
32885       {
32886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32887       };
32888     }
32889   }
32890 }
32891
32892
32893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
32894   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32895   Dali::Layer arg2 ;
32896   Dali::Layer *argp2 ;
32897
32898   arg1 = (Dali::Layer *)jarg1;
32899   argp2 = (Dali::Layer *)jarg2;
32900   if (!argp2) {
32901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32902     return ;
32903   }
32904   arg2 = *argp2;
32905   {
32906     try {
32907       (arg1)->MoveAbove(arg2);
32908     } catch (std::out_of_range& e) {
32909       {
32910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32911       };
32912     } catch (std::exception& e) {
32913       {
32914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32915       };
32916     } catch (...) {
32917       {
32918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32919       };
32920     }
32921   }
32922 }
32923
32924
32925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
32926   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32927   Dali::Layer arg2 ;
32928   Dali::Layer *argp2 ;
32929
32930   arg1 = (Dali::Layer *)jarg1;
32931   argp2 = (Dali::Layer *)jarg2;
32932   if (!argp2) {
32933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32934     return ;
32935   }
32936   arg2 = *argp2;
32937   {
32938     try {
32939       (arg1)->MoveBelow(arg2);
32940     } catch (std::out_of_range& e) {
32941       {
32942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32943       };
32944     } catch (std::exception& e) {
32945       {
32946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32947       };
32948     } catch (...) {
32949       {
32950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32951       };
32952     }
32953   }
32954 }
32955
32956
32957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
32958   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32959   Dali::Layer::Behavior arg2 ;
32960
32961   arg1 = (Dali::Layer *)jarg1;
32962   arg2 = (Dali::Layer::Behavior)jarg2;
32963   {
32964     try {
32965       (arg1)->SetBehavior(arg2);
32966     } catch (std::out_of_range& e) {
32967       {
32968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32969       };
32970     } catch (std::exception& e) {
32971       {
32972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32973       };
32974     } catch (...) {
32975       {
32976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32977       };
32978     }
32979   }
32980 }
32981
32982
32983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
32984   int jresult ;
32985   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32986   Dali::Layer::Behavior result;
32987
32988   arg1 = (Dali::Layer *)jarg1;
32989   {
32990     try {
32991       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
32992     } catch (std::out_of_range& e) {
32993       {
32994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32995       };
32996     } catch (std::exception& e) {
32997       {
32998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32999       };
33000     } catch (...) {
33001       {
33002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33003       };
33004     }
33005   }
33006   jresult = (int)result;
33007   return jresult;
33008 }
33009
33010
33011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
33012   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33013   bool arg2 ;
33014
33015   arg1 = (Dali::Layer *)jarg1;
33016   arg2 = jarg2 ? true : false;
33017   {
33018     try {
33019       (arg1)->SetClipping(arg2);
33020     } catch (std::out_of_range& e) {
33021       {
33022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33023       };
33024     } catch (std::exception& e) {
33025       {
33026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33027       };
33028     } catch (...) {
33029       {
33030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33031       };
33032     }
33033   }
33034 }
33035
33036
33037 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
33038   unsigned int jresult ;
33039   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33040   bool result;
33041
33042   arg1 = (Dali::Layer *)jarg1;
33043   {
33044     try {
33045       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
33046     } catch (std::out_of_range& e) {
33047       {
33048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33049       };
33050     } catch (std::exception& e) {
33051       {
33052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33053       };
33054     } catch (...) {
33055       {
33056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33057       };
33058     }
33059   }
33060   jresult = result;
33061   return jresult;
33062 }
33063
33064
33065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
33066   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33067   int arg2 ;
33068   int arg3 ;
33069   int arg4 ;
33070   int arg5 ;
33071
33072   arg1 = (Dali::Layer *)jarg1;
33073   arg2 = (int)jarg2;
33074   arg3 = (int)jarg3;
33075   arg4 = (int)jarg4;
33076   arg5 = (int)jarg5;
33077   {
33078     try {
33079       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
33080     } catch (std::out_of_range& e) {
33081       {
33082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33083       };
33084     } catch (std::exception& e) {
33085       {
33086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33087       };
33088     } catch (...) {
33089       {
33090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33091       };
33092     }
33093   }
33094 }
33095
33096
33097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
33098   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33099   Dali::ClippingBox arg2 ;
33100   Dali::ClippingBox *argp2 ;
33101
33102   arg1 = (Dali::Layer *)jarg1;
33103   argp2 = (Dali::ClippingBox *)jarg2;
33104   if (!argp2) {
33105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
33106     return ;
33107   }
33108   arg2 = *argp2;
33109   {
33110     try {
33111       (arg1)->SetClippingBox(arg2);
33112     } catch (std::out_of_range& e) {
33113       {
33114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33115       };
33116     } catch (std::exception& e) {
33117       {
33118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33119       };
33120     } catch (...) {
33121       {
33122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33123       };
33124     }
33125   }
33126 }
33127
33128
33129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
33130   void * jresult ;
33131   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33132   Dali::ClippingBox result;
33133
33134   arg1 = (Dali::Layer *)jarg1;
33135   {
33136     try {
33137       result = ((Dali::Layer const *)arg1)->GetClippingBox();
33138     } catch (std::out_of_range& e) {
33139       {
33140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33141       };
33142     } catch (std::exception& e) {
33143       {
33144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33145       };
33146     } catch (...) {
33147       {
33148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33149       };
33150     }
33151   }
33152   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
33153   return jresult;
33154 }
33155
33156
33157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
33158   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33159   bool arg2 ;
33160
33161   arg1 = (Dali::Layer *)jarg1;
33162   arg2 = jarg2 ? true : false;
33163   {
33164     try {
33165       (arg1)->SetDepthTestDisabled(arg2);
33166     } catch (std::out_of_range& e) {
33167       {
33168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33169       };
33170     } catch (std::exception& e) {
33171       {
33172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33173       };
33174     } catch (...) {
33175       {
33176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33177       };
33178     }
33179   }
33180 }
33181
33182
33183 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
33184   unsigned int jresult ;
33185   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33186   bool result;
33187
33188   arg1 = (Dali::Layer *)jarg1;
33189   {
33190     try {
33191       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
33192     } catch (std::out_of_range& e) {
33193       {
33194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33195       };
33196     } catch (std::exception& e) {
33197       {
33198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33199       };
33200     } catch (...) {
33201       {
33202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33203       };
33204     }
33205   }
33206   jresult = result;
33207   return jresult;
33208 }
33209
33210
33211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
33212   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33213   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
33214
33215   arg1 = (Dali::Layer *)jarg1;
33216   arg2 = (Dali::Layer::SortFunctionType)jarg2;
33217   {
33218     try {
33219       (arg1)->SetSortFunction(arg2);
33220     } catch (std::out_of_range& e) {
33221       {
33222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33223       };
33224     } catch (std::exception& e) {
33225       {
33226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33227       };
33228     } catch (...) {
33229       {
33230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33231       };
33232     }
33233   }
33234 }
33235
33236
33237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
33238   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33239   bool arg2 ;
33240
33241   arg1 = (Dali::Layer *)jarg1;
33242   arg2 = jarg2 ? true : false;
33243   {
33244     try {
33245       (arg1)->SetTouchConsumed(arg2);
33246     } catch (std::out_of_range& e) {
33247       {
33248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33249       };
33250     } catch (std::exception& e) {
33251       {
33252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33253       };
33254     } catch (...) {
33255       {
33256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33257       };
33258     }
33259   }
33260 }
33261
33262
33263 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
33264   unsigned int jresult ;
33265   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33266   bool result;
33267
33268   arg1 = (Dali::Layer *)jarg1;
33269   {
33270     try {
33271       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
33272     } catch (std::out_of_range& e) {
33273       {
33274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33275       };
33276     } catch (std::exception& e) {
33277       {
33278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33279       };
33280     } catch (...) {
33281       {
33282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33283       };
33284     }
33285   }
33286   jresult = result;
33287   return jresult;
33288 }
33289
33290
33291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
33292   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33293   bool arg2 ;
33294
33295   arg1 = (Dali::Layer *)jarg1;
33296   arg2 = jarg2 ? true : false;
33297   {
33298     try {
33299       (arg1)->SetHoverConsumed(arg2);
33300     } catch (std::out_of_range& e) {
33301       {
33302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33303       };
33304     } catch (std::exception& e) {
33305       {
33306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33307       };
33308     } catch (...) {
33309       {
33310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33311       };
33312     }
33313   }
33314 }
33315
33316
33317 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
33318   unsigned int jresult ;
33319   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33320   bool result;
33321
33322   arg1 = (Dali::Layer *)jarg1;
33323   {
33324     try {
33325       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
33326     } catch (std::out_of_range& e) {
33327       {
33328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33329       };
33330     } catch (std::exception& e) {
33331       {
33332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33333       };
33334     } catch (...) {
33335       {
33336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33337       };
33338     }
33339   }
33340   jresult = result;
33341   return jresult;
33342 }
33343
33344
33345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
33346   void * jresult ;
33347   Dali::Vector4 *result = 0 ;
33348
33349   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
33350   jresult = (void *)result;
33351   return jresult;
33352 }
33353
33354
33355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
33356   void * jresult ;
33357   Dali::Vector4 *result = 0 ;
33358
33359   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
33360   jresult = (void *)result;
33361   return jresult;
33362 }
33363
33364
33365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
33366   void * jresult ;
33367   Dali::Stage *result = 0 ;
33368
33369   {
33370     try {
33371       result = (Dali::Stage *)new Dali::Stage();
33372     } catch (std::out_of_range& e) {
33373       {
33374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33375       };
33376     } catch (std::exception& e) {
33377       {
33378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33379       };
33380     } catch (...) {
33381       {
33382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33383       };
33384     }
33385   }
33386   jresult = (void *)result;
33387   return jresult;
33388 }
33389
33390
33391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
33392   void * jresult ;
33393   Dali::Stage result;
33394
33395   {
33396     try {
33397       result = Dali::Stage::GetCurrent();
33398     } catch (std::out_of_range& e) {
33399       {
33400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33401       };
33402     } catch (std::exception& e) {
33403       {
33404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33405       };
33406     } catch (...) {
33407       {
33408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33409       };
33410     }
33411   }
33412   jresult = new Dali::Stage((const Dali::Stage &)result);
33413   return jresult;
33414 }
33415
33416
33417 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
33418   unsigned int jresult ;
33419   bool result;
33420
33421   {
33422     try {
33423       result = (bool)Dali::Stage::IsInstalled();
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_delete_Stage(void * jarg1) {
33444   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33445
33446   arg1 = (Dali::Stage *)jarg1;
33447   {
33448     try {
33449       delete arg1;
33450     } catch (std::out_of_range& e) {
33451       {
33452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33453       };
33454     } catch (std::exception& e) {
33455       {
33456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33457       };
33458     } catch (...) {
33459       {
33460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33461       };
33462     }
33463   }
33464 }
33465
33466
33467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
33468   void * jresult ;
33469   Dali::Stage *arg1 = 0 ;
33470   Dali::Stage *result = 0 ;
33471
33472   arg1 = (Dali::Stage *)jarg1;
33473   if (!arg1) {
33474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33475     return 0;
33476   }
33477   {
33478     try {
33479       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
33480     } catch (std::out_of_range& e) {
33481       {
33482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33483       };
33484     } catch (std::exception& e) {
33485       {
33486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33487       };
33488     } catch (...) {
33489       {
33490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33491       };
33492     }
33493   }
33494   jresult = (void *)result;
33495   return jresult;
33496 }
33497
33498
33499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
33500   void * jresult ;
33501   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33502   Dali::Stage *arg2 = 0 ;
33503   Dali::Stage *result = 0 ;
33504
33505   arg1 = (Dali::Stage *)jarg1;
33506   arg2 = (Dali::Stage *)jarg2;
33507   if (!arg2) {
33508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33509     return 0;
33510   }
33511   {
33512     try {
33513       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
33514     } catch (std::out_of_range& e) {
33515       {
33516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33517       };
33518     } catch (std::exception& e) {
33519       {
33520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33521       };
33522     } catch (...) {
33523       {
33524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33525       };
33526     }
33527   }
33528   jresult = (void *)result;
33529   return jresult;
33530 }
33531
33532
33533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
33534   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33535   Dali::Actor *arg2 = 0 ;
33536
33537   arg1 = (Dali::Stage *)jarg1;
33538   arg2 = (Dali::Actor *)jarg2;
33539   if (!arg2) {
33540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33541     return ;
33542   }
33543   {
33544     try {
33545       (arg1)->Add(*arg2);
33546     } catch (std::out_of_range& e) {
33547       {
33548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33549       };
33550     } catch (std::exception& e) {
33551       {
33552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33553       };
33554     } catch (...) {
33555       {
33556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33557       };
33558     }
33559   }
33560 }
33561
33562
33563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
33564   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33565   Dali::Actor *arg2 = 0 ;
33566
33567   arg1 = (Dali::Stage *)jarg1;
33568   arg2 = (Dali::Actor *)jarg2;
33569   if (!arg2) {
33570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33571     return ;
33572   }
33573   {
33574     try {
33575       (arg1)->Remove(*arg2);
33576     } catch (std::out_of_range& e) {
33577       {
33578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33579       };
33580     } catch (std::exception& e) {
33581       {
33582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33583       };
33584     } catch (...) {
33585       {
33586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33587       };
33588     }
33589   }
33590 }
33591
33592
33593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
33594   void * jresult ;
33595   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33596   Dali::Vector2 result;
33597
33598   arg1 = (Dali::Stage *)jarg1;
33599   {
33600     try {
33601       result = ((Dali::Stage const *)arg1)->GetSize();
33602     } catch (std::out_of_range& e) {
33603       {
33604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33605       };
33606     } catch (std::exception& e) {
33607       {
33608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33609       };
33610     } catch (...) {
33611       {
33612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33613       };
33614     }
33615   }
33616   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33617   return jresult;
33618 }
33619
33620
33621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
33622   void * jresult ;
33623   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33624   Dali::RenderTaskList result;
33625
33626   arg1 = (Dali::Stage *)jarg1;
33627   {
33628     try {
33629       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
33630     } catch (std::out_of_range& e) {
33631       {
33632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33633       };
33634     } catch (std::exception& e) {
33635       {
33636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33637       };
33638     } catch (...) {
33639       {
33640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33641       };
33642     }
33643   }
33644   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
33645   return jresult;
33646 }
33647
33648
33649 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
33650   unsigned int jresult ;
33651   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33652   unsigned int result;
33653
33654   arg1 = (Dali::Stage *)jarg1;
33655   {
33656     try {
33657       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
33658     } catch (std::out_of_range& e) {
33659       {
33660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33661       };
33662     } catch (std::exception& e) {
33663       {
33664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33665       };
33666     } catch (...) {
33667       {
33668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33669       };
33670     }
33671   }
33672   jresult = result;
33673   return jresult;
33674 }
33675
33676
33677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
33678   void * jresult ;
33679   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33680   unsigned int arg2 ;
33681   Dali::Layer result;
33682
33683   arg1 = (Dali::Stage *)jarg1;
33684   arg2 = (unsigned int)jarg2;
33685   {
33686     try {
33687       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
33688     } catch (std::out_of_range& e) {
33689       {
33690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33691       };
33692     } catch (std::exception& e) {
33693       {
33694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33695       };
33696     } catch (...) {
33697       {
33698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33699       };
33700     }
33701   }
33702   jresult = new Dali::Layer((const Dali::Layer &)result);
33703   return jresult;
33704 }
33705
33706
33707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
33708   void * jresult ;
33709   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33710   Dali::Layer result;
33711
33712   arg1 = (Dali::Stage *)jarg1;
33713   {
33714     try {
33715       result = ((Dali::Stage const *)arg1)->GetRootLayer();
33716     } catch (std::out_of_range& e) {
33717       {
33718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33719       };
33720     } catch (std::exception& e) {
33721       {
33722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33723       };
33724     } catch (...) {
33725       {
33726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33727       };
33728     }
33729   }
33730   jresult = new Dali::Layer((const Dali::Layer &)result);
33731   return jresult;
33732 }
33733
33734
33735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
33736   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33737   Dali::Vector4 arg2 ;
33738   Dali::Vector4 *argp2 ;
33739
33740   arg1 = (Dali::Stage *)jarg1;
33741   argp2 = (Dali::Vector4 *)jarg2;
33742   if (!argp2) {
33743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
33744     return ;
33745   }
33746   arg2 = *argp2;
33747   {
33748     try {
33749       (arg1)->SetBackgroundColor(arg2);
33750     } catch (std::out_of_range& e) {
33751       {
33752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33753       };
33754     } catch (std::exception& e) {
33755       {
33756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33757       };
33758     } catch (...) {
33759       {
33760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33761       };
33762     }
33763   }
33764 }
33765
33766
33767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
33768   void * jresult ;
33769   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33770   Dali::Vector4 result;
33771
33772   arg1 = (Dali::Stage *)jarg1;
33773   {
33774     try {
33775       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
33776     } catch (std::out_of_range& e) {
33777       {
33778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33779       };
33780     } catch (std::exception& e) {
33781       {
33782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33783       };
33784     } catch (...) {
33785       {
33786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33787       };
33788     }
33789   }
33790   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
33791   return jresult;
33792 }
33793
33794
33795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
33796   void * jresult ;
33797   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33798   Dali::Vector2 result;
33799
33800   arg1 = (Dali::Stage *)jarg1;
33801   {
33802     try {
33803       result = ((Dali::Stage const *)arg1)->GetDpi();
33804     } catch (std::out_of_range& e) {
33805       {
33806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33807       };
33808     } catch (std::exception& e) {
33809       {
33810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33811       };
33812     } catch (...) {
33813       {
33814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33815       };
33816     }
33817   }
33818   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33819   return jresult;
33820 }
33821
33822
33823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
33824   void * jresult ;
33825   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33826   Dali::ObjectRegistry result;
33827
33828   arg1 = (Dali::Stage *)jarg1;
33829   {
33830     try {
33831       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
33832     } catch (std::out_of_range& e) {
33833       {
33834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33835       };
33836     } catch (std::exception& e) {
33837       {
33838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33839       };
33840     } catch (...) {
33841       {
33842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33843       };
33844     }
33845   }
33846   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
33847   return jresult;
33848 }
33849
33850
33851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
33852   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33853   float arg2 ;
33854
33855   arg1 = (Dali::Stage *)jarg1;
33856   arg2 = (float)jarg2;
33857   {
33858     try {
33859       (arg1)->KeepRendering(arg2);
33860     } catch (std::out_of_range& e) {
33861       {
33862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33863       };
33864     } catch (std::exception& e) {
33865       {
33866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33867       };
33868     } catch (...) {
33869       {
33870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33871       };
33872     }
33873   }
33874 }
33875
33876
33877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
33878   void * jresult ;
33879   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33880   Dali::Stage::KeyEventSignalType *result = 0 ;
33881
33882   arg1 = (Dali::Stage *)jarg1;
33883   {
33884     try {
33885       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
33886     } catch (std::out_of_range& e) {
33887       {
33888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33889       };
33890     } catch (std::exception& e) {
33891       {
33892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33893       };
33894     } catch (...) {
33895       {
33896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33897       };
33898     }
33899   }
33900   jresult = (void *)result;
33901   return jresult;
33902 }
33903
33904
33905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
33906   void * jresult ;
33907   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33908   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
33909
33910   arg1 = (Dali::Stage *)jarg1;
33911   {
33912     try {
33913       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
33914     } catch (std::out_of_range& e) {
33915       {
33916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33917       };
33918     } catch (std::exception& e) {
33919       {
33920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33921       };
33922     } catch (...) {
33923       {
33924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33925       };
33926     }
33927   }
33928   jresult = (void *)result;
33929   return jresult;
33930 }
33931
33932
33933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
33934   void * jresult ;
33935   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33936   Dali::Stage::TouchSignalType *result = 0 ;
33937
33938   arg1 = (Dali::Stage *)jarg1;
33939   {
33940     try {
33941       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
33942     } catch (std::out_of_range& e) {
33943       {
33944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33945       };
33946     } catch (std::exception& e) {
33947       {
33948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33949       };
33950     } catch (...) {
33951       {
33952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33953       };
33954     }
33955   }
33956   jresult = (void *)result;
33957   return jresult;
33958 }
33959
33960
33961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
33962   void * jresult ;
33963   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33964   Dali::Stage::WheelEventSignalType *result = 0 ;
33965
33966   arg1 = (Dali::Stage *)jarg1;
33967   {
33968     try {
33969       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
33970     } catch (std::out_of_range& e) {
33971       {
33972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33973       };
33974     } catch (std::exception& e) {
33975       {
33976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33977       };
33978     } catch (...) {
33979       {
33980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33981       };
33982     }
33983   }
33984   jresult = (void *)result;
33985   return jresult;
33986 }
33987
33988
33989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
33990   void * jresult ;
33991   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33992   Dali::Stage::ContextStatusSignal *result = 0 ;
33993
33994   arg1 = (Dali::Stage *)jarg1;
33995   {
33996     try {
33997       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
33998     } catch (std::out_of_range& e) {
33999       {
34000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34001       };
34002     } catch (std::exception& e) {
34003       {
34004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34005       };
34006     } catch (...) {
34007       {
34008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34009       };
34010     }
34011   }
34012   jresult = (void *)result;
34013   return jresult;
34014 }
34015
34016
34017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
34018   void * jresult ;
34019   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34020   Dali::Stage::ContextStatusSignal *result = 0 ;
34021
34022   arg1 = (Dali::Stage *)jarg1;
34023   {
34024     try {
34025       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
34026     } catch (std::out_of_range& e) {
34027       {
34028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34029       };
34030     } catch (std::exception& e) {
34031       {
34032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34033       };
34034     } catch (...) {
34035       {
34036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34037       };
34038     }
34039   }
34040   jresult = (void *)result;
34041   return jresult;
34042 }
34043
34044
34045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
34046   void * jresult ;
34047   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34048   Dali::Stage::SceneCreatedSignalType *result = 0 ;
34049
34050   arg1 = (Dali::Stage *)jarg1;
34051   {
34052     try {
34053       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
34054     } catch (std::out_of_range& e) {
34055       {
34056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34057       };
34058     } catch (std::exception& e) {
34059       {
34060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34061       };
34062     } catch (...) {
34063       {
34064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34065       };
34066     }
34067   }
34068   jresult = (void *)result;
34069   return jresult;
34070 }
34071
34072
34073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
34074   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
34075
34076   arg1 = (Dali::RelayoutContainer *)jarg1;
34077   {
34078     try {
34079       delete arg1;
34080     } catch (std::out_of_range& e) {
34081       {
34082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34083       };
34084     } catch (std::exception& e) {
34085       {
34086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34087       };
34088     } catch (...) {
34089       {
34090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34091       };
34092     }
34093   }
34094 }
34095
34096
34097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
34098   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
34099   Dali::Actor *arg2 = 0 ;
34100   Dali::Vector2 *arg3 = 0 ;
34101
34102   arg1 = (Dali::RelayoutContainer *)jarg1;
34103   arg2 = (Dali::Actor *)jarg2;
34104   if (!arg2) {
34105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34106     return ;
34107   }
34108   arg3 = (Dali::Vector2 *)jarg3;
34109   if (!arg3) {
34110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34111     return ;
34112   }
34113   {
34114     try {
34115       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
34116     } catch (std::out_of_range& e) {
34117       {
34118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34119       };
34120     } catch (std::exception& e) {
34121       {
34122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34123       };
34124     } catch (...) {
34125       {
34126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34127       };
34128     }
34129   }
34130 }
34131
34132
34133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
34134   void * jresult ;
34135   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34136   Dali::CustomActor result;
34137
34138   arg1 = (Dali::CustomActorImpl *)jarg1;
34139   {
34140     try {
34141       result = ((Dali::CustomActorImpl const *)arg1)->Self();
34142     } catch (std::out_of_range& e) {
34143       {
34144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34145       };
34146     } catch (std::exception& e) {
34147       {
34148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34149       };
34150     } catch (...) {
34151       {
34152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34153       };
34154     }
34155   }
34156   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
34157   return jresult;
34158 }
34159
34160
34161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
34162   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34163   int arg2 ;
34164
34165   arg1 = (Dali::CustomActorImpl *)jarg1;
34166   arg2 = (int)jarg2;
34167   {
34168     try {
34169       (arg1)->OnStageConnection(arg2);
34170     } catch (std::out_of_range& e) {
34171       {
34172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34173       };
34174     } catch (std::exception& e) {
34175       {
34176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34177       };
34178     } catch (...) {
34179       {
34180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34181       };
34182     }
34183   }
34184 }
34185
34186
34187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
34188   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34189
34190   arg1 = (Dali::CustomActorImpl *)jarg1;
34191   {
34192     try {
34193       (arg1)->OnStageDisconnection();
34194     } catch (std::out_of_range& e) {
34195       {
34196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34197       };
34198     } catch (std::exception& e) {
34199       {
34200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34201       };
34202     } catch (...) {
34203       {
34204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34205       };
34206     }
34207   }
34208 }
34209
34210
34211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
34212   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34213   Dali::Actor *arg2 = 0 ;
34214
34215   arg1 = (Dali::CustomActorImpl *)jarg1;
34216   arg2 = (Dali::Actor *)jarg2;
34217   if (!arg2) {
34218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34219     return ;
34220   }
34221   {
34222     try {
34223       (arg1)->OnChildAdd(*arg2);
34224     } catch (std::out_of_range& e) {
34225       {
34226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34227       };
34228     } catch (std::exception& e) {
34229       {
34230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34231       };
34232     } catch (...) {
34233       {
34234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34235       };
34236     }
34237   }
34238 }
34239
34240
34241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
34242   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34243   Dali::Actor *arg2 = 0 ;
34244
34245   arg1 = (Dali::CustomActorImpl *)jarg1;
34246   arg2 = (Dali::Actor *)jarg2;
34247   if (!arg2) {
34248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34249     return ;
34250   }
34251   {
34252     try {
34253       (arg1)->OnChildRemove(*arg2);
34254     } catch (std::out_of_range& e) {
34255       {
34256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34257       };
34258     } catch (std::exception& e) {
34259       {
34260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34261       };
34262     } catch (...) {
34263       {
34264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34265       };
34266     }
34267   }
34268 }
34269
34270
34271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
34272   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34273   Dali::Property::Index arg2 ;
34274   Dali::Property::Value arg3 ;
34275   Dali::Property::Value *argp3 ;
34276
34277   arg1 = (Dali::CustomActorImpl *)jarg1;
34278   arg2 = (Dali::Property::Index)jarg2;
34279   argp3 = (Dali::Property::Value *)jarg3;
34280   if (!argp3) {
34281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
34282     return ;
34283   }
34284   arg3 = *argp3;
34285   {
34286     try {
34287       (arg1)->OnPropertySet(arg2,arg3);
34288     } catch (std::out_of_range& e) {
34289       {
34290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34291       };
34292     } catch (std::exception& e) {
34293       {
34294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34295       };
34296     } catch (...) {
34297       {
34298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34299       };
34300     }
34301   }
34302 }
34303
34304
34305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
34306   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34307   Dali::Vector3 *arg2 = 0 ;
34308
34309   arg1 = (Dali::CustomActorImpl *)jarg1;
34310   arg2 = (Dali::Vector3 *)jarg2;
34311   if (!arg2) {
34312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34313     return ;
34314   }
34315   {
34316     try {
34317       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
34318     } catch (std::out_of_range& e) {
34319       {
34320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34321       };
34322     } catch (std::exception& e) {
34323       {
34324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34325       };
34326     } catch (...) {
34327       {
34328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34329       };
34330     }
34331   }
34332 }
34333
34334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
34335   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34336   Dali::Animation *arg2 = 0 ;
34337   Dali::Vector3 *arg3 = 0 ;
34338
34339   arg1 = (Dali::CustomActorImpl *)jarg1;
34340   arg2 = (Dali::Animation *)jarg2;
34341   if (!arg2) {
34342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
34343     return ;
34344   }
34345   arg3 = (Dali::Vector3 *)jarg3;
34346   if (!arg3) {
34347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34348     return ;
34349   }
34350   {
34351     try {
34352       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
34353     } catch (std::out_of_range& e) {
34354       {
34355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34356       };
34357     } catch (std::exception& e) {
34358       {
34359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34360       };
34361     } catch (...) {
34362       {
34363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34364       };
34365     }
34366   }
34367 }
34368
34369
34370 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
34371   unsigned int jresult ;
34372   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34373   Dali::TouchEvent *arg2 = 0 ;
34374   bool result;
34375
34376   arg1 = (Dali::CustomActorImpl *)jarg1;
34377   arg2 = (Dali::TouchEvent *)jarg2;
34378   if (!arg2) {
34379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
34380     return 0;
34381   }
34382   {
34383     try {
34384       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
34385     } catch (std::out_of_range& e) {
34386       {
34387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34388       };
34389     } catch (std::exception& e) {
34390       {
34391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34392       };
34393     } catch (...) {
34394       {
34395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34396       };
34397     }
34398   }
34399   jresult = result;
34400   return jresult;
34401 }
34402
34403
34404 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
34405   unsigned int jresult ;
34406   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34407   Dali::HoverEvent *arg2 = 0 ;
34408   bool result;
34409
34410   arg1 = (Dali::CustomActorImpl *)jarg1;
34411   arg2 = (Dali::HoverEvent *)jarg2;
34412   if (!arg2) {
34413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
34414     return 0;
34415   }
34416   {
34417     try {
34418       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
34419     } catch (std::out_of_range& e) {
34420       {
34421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34422       };
34423     } catch (std::exception& e) {
34424       {
34425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34426       };
34427     } catch (...) {
34428       {
34429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34430       };
34431     }
34432   }
34433   jresult = result;
34434   return jresult;
34435 }
34436
34437
34438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
34439   unsigned int jresult ;
34440   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34441   Dali::KeyEvent *arg2 = 0 ;
34442   bool result;
34443
34444   arg1 = (Dali::CustomActorImpl *)jarg1;
34445   arg2 = (Dali::KeyEvent *)jarg2;
34446   if (!arg2) {
34447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
34448     return 0;
34449   }
34450   {
34451     try {
34452       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
34453     } catch (std::out_of_range& e) {
34454       {
34455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34456       };
34457     } catch (std::exception& e) {
34458       {
34459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34460       };
34461     } catch (...) {
34462       {
34463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34464       };
34465     }
34466   }
34467   jresult = result;
34468   return jresult;
34469 }
34470
34471
34472 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
34473   unsigned int jresult ;
34474   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34475   Dali::WheelEvent *arg2 = 0 ;
34476   bool result;
34477
34478   arg1 = (Dali::CustomActorImpl *)jarg1;
34479   arg2 = (Dali::WheelEvent *)jarg2;
34480   if (!arg2) {
34481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
34482     return 0;
34483   }
34484   {
34485     try {
34486       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
34487     } catch (std::out_of_range& e) {
34488       {
34489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34490       };
34491     } catch (std::exception& e) {
34492       {
34493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34494       };
34495     } catch (...) {
34496       {
34497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34498       };
34499     }
34500   }
34501   jresult = result;
34502   return jresult;
34503 }
34504
34505
34506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
34507   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34508   Dali::Vector2 *arg2 = 0 ;
34509   Dali::RelayoutContainer *arg3 = 0 ;
34510
34511   arg1 = (Dali::CustomActorImpl *)jarg1;
34512   arg2 = (Dali::Vector2 *)jarg2;
34513   if (!arg2) {
34514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34515     return ;
34516   }
34517   arg3 = (Dali::RelayoutContainer *)jarg3;
34518   if (!arg3) {
34519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
34520     return ;
34521   }
34522   {
34523     try {
34524       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
34525     } catch (std::out_of_range& e) {
34526       {
34527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34528       };
34529     } catch (std::exception& e) {
34530       {
34531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34532       };
34533     } catch (...) {
34534       {
34535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34536       };
34537     }
34538   }
34539 }
34540
34541
34542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
34543   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34544   Dali::ResizePolicy::Type arg2 ;
34545   Dali::Dimension::Type arg3 ;
34546
34547   arg1 = (Dali::CustomActorImpl *)jarg1;
34548   arg2 = (Dali::ResizePolicy::Type)jarg2;
34549   arg3 = (Dali::Dimension::Type)jarg3;
34550   {
34551     try {
34552       (arg1)->OnSetResizePolicy(arg2,arg3);
34553     } catch (std::out_of_range& e) {
34554       {
34555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34556       };
34557     } catch (std::exception& e) {
34558       {
34559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34560       };
34561     } catch (...) {
34562       {
34563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34564       };
34565     }
34566   }
34567 }
34568
34569
34570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
34571   void * jresult ;
34572   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34573   Dali::Vector3 result;
34574
34575   arg1 = (Dali::CustomActorImpl *)jarg1;
34576   {
34577     try {
34578       result = (arg1)->GetNaturalSize();
34579     } catch (std::out_of_range& e) {
34580       {
34581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34582       };
34583     } catch (std::exception& e) {
34584       {
34585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34586       };
34587     } catch (...) {
34588       {
34589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34590       };
34591     }
34592   }
34593   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34594   return jresult;
34595 }
34596
34597
34598 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
34599   float jresult ;
34600   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34601   Dali::Actor *arg2 = 0 ;
34602   Dali::Dimension::Type arg3 ;
34603   float result;
34604
34605   arg1 = (Dali::CustomActorImpl *)jarg1;
34606   arg2 = (Dali::Actor *)jarg2;
34607   if (!arg2) {
34608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34609     return 0;
34610   }
34611   arg3 = (Dali::Dimension::Type)jarg3;
34612   {
34613     try {
34614       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
34615     } catch (std::out_of_range& e) {
34616       {
34617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34618       };
34619     } catch (std::exception& e) {
34620       {
34621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34622       };
34623     } catch (...) {
34624       {
34625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34626       };
34627     }
34628   }
34629   jresult = result;
34630   return jresult;
34631 }
34632
34633
34634 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
34635   float jresult ;
34636   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34637   float arg2 ;
34638   float result;
34639
34640   arg1 = (Dali::CustomActorImpl *)jarg1;
34641   arg2 = (float)jarg2;
34642   {
34643     try {
34644       result = (float)(arg1)->GetHeightForWidth(arg2);
34645     } catch (std::out_of_range& e) {
34646       {
34647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34648       };
34649     } catch (std::exception& e) {
34650       {
34651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34652       };
34653     } catch (...) {
34654       {
34655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34656       };
34657     }
34658   }
34659   jresult = result;
34660   return jresult;
34661 }
34662
34663
34664 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
34665   float jresult ;
34666   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34667   float arg2 ;
34668   float result;
34669
34670   arg1 = (Dali::CustomActorImpl *)jarg1;
34671   arg2 = (float)jarg2;
34672   {
34673     try {
34674       result = (float)(arg1)->GetWidthForHeight(arg2);
34675     } catch (std::out_of_range& e) {
34676       {
34677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34678       };
34679     } catch (std::exception& e) {
34680       {
34681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34682       };
34683     } catch (...) {
34684       {
34685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34686       };
34687     }
34688   }
34689   jresult = result;
34690   return jresult;
34691 }
34692
34693
34694 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
34695   unsigned int jresult ;
34696   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34697   Dali::Dimension::Type arg2 ;
34698   bool result;
34699
34700   arg1 = (Dali::CustomActorImpl *)jarg1;
34701   arg2 = (Dali::Dimension::Type)jarg2;
34702   {
34703     try {
34704       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
34705     } catch (std::out_of_range& e) {
34706       {
34707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34708       };
34709     } catch (std::exception& e) {
34710       {
34711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34712       };
34713     } catch (...) {
34714       {
34715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34716       };
34717     }
34718   }
34719   jresult = result;
34720   return jresult;
34721 }
34722
34723
34724 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
34725   unsigned int jresult ;
34726   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34727   bool result;
34728
34729   arg1 = (Dali::CustomActorImpl *)jarg1;
34730   {
34731     try {
34732       result = (bool)(arg1)->RelayoutDependentOnChildren();
34733     } catch (std::out_of_range& e) {
34734       {
34735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34736       };
34737     } catch (std::exception& e) {
34738       {
34739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34740       };
34741     } catch (...) {
34742       {
34743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34744       };
34745     }
34746   }
34747   jresult = result;
34748   return jresult;
34749 }
34750
34751
34752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
34753   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34754   Dali::Dimension::Type arg2 ;
34755
34756   arg1 = (Dali::CustomActorImpl *)jarg1;
34757   arg2 = (Dali::Dimension::Type)jarg2;
34758   {
34759     try {
34760       (arg1)->OnCalculateRelayoutSize(arg2);
34761     } catch (std::out_of_range& e) {
34762       {
34763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34764       };
34765     } catch (std::exception& e) {
34766       {
34767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34768       };
34769     } catch (...) {
34770       {
34771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34772       };
34773     }
34774   }
34775 }
34776
34777
34778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
34779   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34780   float arg2 ;
34781   Dali::Dimension::Type arg3 ;
34782
34783   arg1 = (Dali::CustomActorImpl *)jarg1;
34784   arg2 = (float)jarg2;
34785   arg3 = (Dali::Dimension::Type)jarg3;
34786   {
34787     try {
34788       (arg1)->OnLayoutNegotiated(arg2,arg3);
34789     } catch (std::out_of_range& e) {
34790       {
34791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34792       };
34793     } catch (std::exception& e) {
34794       {
34795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34796       };
34797     } catch (...) {
34798       {
34799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34800       };
34801     }
34802   }
34803 }
34804
34805
34806 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
34807   unsigned int jresult ;
34808   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34809   bool result;
34810
34811   arg1 = (Dali::CustomActorImpl *)jarg1;
34812   {
34813     try {
34814       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
34815     } catch (std::out_of_range& e) {
34816       {
34817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34818       };
34819     } catch (std::exception& e) {
34820       {
34821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34822       };
34823     } catch (...) {
34824       {
34825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34826       };
34827     }
34828   }
34829   jresult = result;
34830   return jresult;
34831 }
34832
34833
34834 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
34835   unsigned int jresult ;
34836   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34837   bool result;
34838
34839   arg1 = (Dali::CustomActorImpl *)jarg1;
34840   {
34841     try {
34842       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
34843     } catch (std::out_of_range& e) {
34844       {
34845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34846       };
34847     } catch (std::exception& e) {
34848       {
34849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34850       };
34851     } catch (...) {
34852       {
34853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34854       };
34855     }
34856   }
34857   jresult = result;
34858   return jresult;
34859 }
34860
34861
34862 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
34863   unsigned int jresult ;
34864   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34865   bool result;
34866
34867   arg1 = (Dali::CustomActorImpl *)jarg1;
34868   {
34869     try {
34870       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
34871     } catch (std::out_of_range& e) {
34872       {
34873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34874       };
34875     } catch (std::exception& e) {
34876       {
34877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34878       };
34879     } catch (...) {
34880       {
34881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34882       };
34883     }
34884   }
34885   jresult = result;
34886   return jresult;
34887 }
34888
34889
34890 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
34891   unsigned int jresult ;
34892   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34893   bool result;
34894
34895   arg1 = (Dali::CustomActorImpl *)jarg1;
34896   {
34897     try {
34898       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
34899     } catch (std::out_of_range& e) {
34900       {
34901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34902       };
34903     } catch (std::exception& e) {
34904       {
34905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34906       };
34907     } catch (...) {
34908       {
34909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34910       };
34911     }
34912   }
34913   jresult = result;
34914   return jresult;
34915 }
34916
34917
34918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
34919   void * jresult ;
34920   Dali::CustomActor *result = 0 ;
34921
34922   {
34923     try {
34924       result = (Dali::CustomActor *)new Dali::CustomActor();
34925     } catch (std::out_of_range& e) {
34926       {
34927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34928       };
34929     } catch (std::exception& e) {
34930       {
34931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34932       };
34933     } catch (...) {
34934       {
34935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34936       };
34937     }
34938   }
34939   jresult = (void *)result;
34940   return jresult;
34941 }
34942
34943
34944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
34945   void * jresult ;
34946   Dali::BaseHandle arg1 ;
34947   Dali::BaseHandle *argp1 ;
34948   Dali::CustomActor result;
34949
34950   argp1 = (Dali::BaseHandle *)jarg1;
34951   if (!argp1) {
34952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
34953     return 0;
34954   }
34955   arg1 = *argp1;
34956   {
34957     try {
34958       result = Dali::CustomActor::DownCast(arg1);
34959     } catch (std::out_of_range& e) {
34960       {
34961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34962       };
34963     } catch (std::exception& e) {
34964       {
34965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34966       };
34967     } catch (...) {
34968       {
34969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34970       };
34971     }
34972   }
34973   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
34974   return jresult;
34975 }
34976
34977
34978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
34979   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
34980
34981   arg1 = (Dali::CustomActor *)jarg1;
34982   {
34983     try {
34984       delete arg1;
34985     } catch (std::out_of_range& e) {
34986       {
34987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34988       };
34989     } catch (std::exception& e) {
34990       {
34991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34992       };
34993     } catch (...) {
34994       {
34995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34996       };
34997     }
34998   }
34999 }
35000
35001
35002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
35003   void * jresult ;
35004   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35005   Dali::CustomActorImpl *result = 0 ;
35006
35007   arg1 = (Dali::CustomActor *)jarg1;
35008   {
35009     try {
35010       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
35011     } catch (std::out_of_range& e) {
35012       {
35013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35014       };
35015     } catch (std::exception& e) {
35016       {
35017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35018       };
35019     } catch (...) {
35020       {
35021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35022       };
35023     }
35024   }
35025   jresult = (void *)result;
35026   return jresult;
35027 }
35028
35029
35030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
35031   void * jresult ;
35032   Dali::CustomActorImpl *arg1 = 0 ;
35033   Dali::CustomActor *result = 0 ;
35034
35035   arg1 = (Dali::CustomActorImpl *)jarg1;
35036   if (!arg1) {
35037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
35038     return 0;
35039   }
35040   {
35041     try {
35042       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
35043     } catch (std::out_of_range& e) {
35044       {
35045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35046       };
35047     } catch (std::exception& e) {
35048       {
35049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35050       };
35051     } catch (...) {
35052       {
35053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35054       };
35055     }
35056   }
35057   jresult = (void *)result;
35058   return jresult;
35059 }
35060
35061
35062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
35063   void * jresult ;
35064   Dali::CustomActor *arg1 = 0 ;
35065   Dali::CustomActor *result = 0 ;
35066
35067   arg1 = (Dali::CustomActor *)jarg1;
35068   if (!arg1) {
35069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
35070     return 0;
35071   }
35072   {
35073     try {
35074       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
35075     } catch (std::out_of_range& e) {
35076       {
35077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35078       };
35079     } catch (std::exception& e) {
35080       {
35081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35082       };
35083     } catch (...) {
35084       {
35085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35086       };
35087     }
35088   }
35089   jresult = (void *)result;
35090   return jresult;
35091 }
35092
35093
35094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
35095   void * jresult ;
35096   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35097   Dali::CustomActor *arg2 = 0 ;
35098   Dali::CustomActor *result = 0 ;
35099
35100   arg1 = (Dali::CustomActor *)jarg1;
35101   arg2 = (Dali::CustomActor *)jarg2;
35102   if (!arg2) {
35103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
35104     return 0;
35105   }
35106   {
35107     try {
35108       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
35109     } catch (std::out_of_range& e) {
35110       {
35111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35112       };
35113     } catch (std::exception& e) {
35114       {
35115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35116       };
35117     } catch (...) {
35118       {
35119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35120       };
35121     }
35122   }
35123   jresult = (void *)result;
35124   return jresult;
35125 }
35126
35127
35128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
35129   int jresult ;
35130   int result;
35131
35132   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
35133   jresult = (int)result;
35134   return jresult;
35135 }
35136
35137
35138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
35139   int jresult ;
35140   int result;
35141
35142   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
35143   jresult = (int)result;
35144   return jresult;
35145 }
35146
35147
35148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
35149   int jresult ;
35150   int result;
35151
35152   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
35153   jresult = (int)result;
35154   return jresult;
35155 }
35156
35157
35158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
35159   int jresult ;
35160   int result;
35161
35162   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
35163   jresult = (int)result;
35164   return jresult;
35165 }
35166
35167
35168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
35169   int jresult ;
35170   int result;
35171
35172   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
35173   jresult = (int)result;
35174   return jresult;
35175 }
35176
35177
35178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
35179   int jresult ;
35180   int result;
35181
35182   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
35183   jresult = (int)result;
35184   return jresult;
35185 }
35186
35187
35188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
35189   int jresult ;
35190   int result;
35191
35192   result = (int)Dali::PanGestureDetector::Property::PANNING;
35193   jresult = (int)result;
35194   return jresult;
35195 }
35196
35197
35198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
35199   void * jresult ;
35200   Dali::PanGestureDetector::Property *result = 0 ;
35201
35202   {
35203     try {
35204       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
35205     } catch (std::out_of_range& e) {
35206       {
35207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35208       };
35209     } catch (std::exception& e) {
35210       {
35211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35212       };
35213     } catch (...) {
35214       {
35215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35216       };
35217     }
35218   }
35219   jresult = (void *)result;
35220   return jresult;
35221 }
35222
35223
35224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
35225   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
35226
35227   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
35228   {
35229     try {
35230       delete arg1;
35231     } catch (std::out_of_range& e) {
35232       {
35233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35234       };
35235     } catch (std::exception& e) {
35236       {
35237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35238       };
35239     } catch (...) {
35240       {
35241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35242       };
35243     }
35244   }
35245 }
35246
35247
35248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
35249   void * jresult ;
35250   Dali::Radian *result = 0 ;
35251
35252   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
35253   jresult = (void *)result;
35254   return jresult;
35255 }
35256
35257
35258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
35259   void * jresult ;
35260   Dali::Radian *result = 0 ;
35261
35262   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
35263   jresult = (void *)result;
35264   return jresult;
35265 }
35266
35267
35268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
35269   void * jresult ;
35270   Dali::Radian *result = 0 ;
35271
35272   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
35273   jresult = (void *)result;
35274   return jresult;
35275 }
35276
35277
35278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
35279   void * jresult ;
35280   Dali::Radian *result = 0 ;
35281
35282   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
35283   jresult = (void *)result;
35284   return jresult;
35285 }
35286
35287
35288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
35289   void * jresult ;
35290   Dali::Radian *result = 0 ;
35291
35292   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
35293   jresult = (void *)result;
35294   return jresult;
35295 }
35296
35297
35298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
35299   void * jresult ;
35300   Dali::Radian *result = 0 ;
35301
35302   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
35303   jresult = (void *)result;
35304   return jresult;
35305 }
35306
35307
35308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
35309   void * jresult ;
35310   Dali::Radian *result = 0 ;
35311
35312   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
35313   jresult = (void *)result;
35314   return jresult;
35315 }
35316
35317
35318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
35319   void * jresult ;
35320   Dali::PanGestureDetector *result = 0 ;
35321
35322   {
35323     try {
35324       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
35325     } catch (std::out_of_range& e) {
35326       {
35327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35328       };
35329     } catch (std::exception& e) {
35330       {
35331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35332       };
35333     } catch (...) {
35334       {
35335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35336       };
35337     }
35338   }
35339   jresult = (void *)result;
35340   return jresult;
35341 }
35342
35343
35344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
35345   void * jresult ;
35346   Dali::PanGestureDetector result;
35347
35348   {
35349     try {
35350       result = Dali::PanGestureDetector::New();
35351     } catch (std::out_of_range& e) {
35352       {
35353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35354       };
35355     } catch (std::exception& e) {
35356       {
35357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35358       };
35359     } catch (...) {
35360       {
35361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35362       };
35363     }
35364   }
35365   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35366   return jresult;
35367 }
35368
35369
35370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
35371   void * jresult ;
35372   Dali::BaseHandle arg1 ;
35373   Dali::BaseHandle *argp1 ;
35374   Dali::PanGestureDetector result;
35375
35376   argp1 = (Dali::BaseHandle *)jarg1;
35377   if (!argp1) {
35378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35379     return 0;
35380   }
35381   arg1 = *argp1;
35382   {
35383     try {
35384       result = Dali::PanGestureDetector::DownCast(arg1);
35385     } catch (std::out_of_range& e) {
35386       {
35387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35388       };
35389     } catch (std::exception& e) {
35390       {
35391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35392       };
35393     } catch (...) {
35394       {
35395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35396       };
35397     }
35398   }
35399   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35400   return jresult;
35401 }
35402
35403
35404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
35405   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35406
35407   arg1 = (Dali::PanGestureDetector *)jarg1;
35408   {
35409     try {
35410       delete arg1;
35411     } catch (std::out_of_range& e) {
35412       {
35413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35414       };
35415     } catch (std::exception& e) {
35416       {
35417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35418       };
35419     } catch (...) {
35420       {
35421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35422       };
35423     }
35424   }
35425 }
35426
35427
35428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
35429   void * jresult ;
35430   Dali::PanGestureDetector *arg1 = 0 ;
35431   Dali::PanGestureDetector *result = 0 ;
35432
35433   arg1 = (Dali::PanGestureDetector *)jarg1;
35434   if (!arg1) {
35435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35436     return 0;
35437   }
35438   {
35439     try {
35440       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
35441     } catch (std::out_of_range& e) {
35442       {
35443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35444       };
35445     } catch (std::exception& e) {
35446       {
35447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35448       };
35449     } catch (...) {
35450       {
35451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35452       };
35453     }
35454   }
35455   jresult = (void *)result;
35456   return jresult;
35457 }
35458
35459
35460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
35461   void * jresult ;
35462   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35463   Dali::PanGestureDetector *arg2 = 0 ;
35464   Dali::PanGestureDetector *result = 0 ;
35465
35466   arg1 = (Dali::PanGestureDetector *)jarg1;
35467   arg2 = (Dali::PanGestureDetector *)jarg2;
35468   if (!arg2) {
35469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35470     return 0;
35471   }
35472   {
35473     try {
35474       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
35475     } catch (std::out_of_range& e) {
35476       {
35477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35478       };
35479     } catch (std::exception& e) {
35480       {
35481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35482       };
35483     } catch (...) {
35484       {
35485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35486       };
35487     }
35488   }
35489   jresult = (void *)result;
35490   return jresult;
35491 }
35492
35493
35494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
35495   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35496   unsigned int arg2 ;
35497
35498   arg1 = (Dali::PanGestureDetector *)jarg1;
35499   arg2 = (unsigned int)jarg2;
35500   {
35501     try {
35502       (arg1)->SetMinimumTouchesRequired(arg2);
35503     } catch (std::out_of_range& e) {
35504       {
35505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35506       };
35507     } catch (std::exception& e) {
35508       {
35509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35510       };
35511     } catch (...) {
35512       {
35513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35514       };
35515     }
35516   }
35517 }
35518
35519
35520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
35521   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35522   unsigned int arg2 ;
35523
35524   arg1 = (Dali::PanGestureDetector *)jarg1;
35525   arg2 = (unsigned int)jarg2;
35526   {
35527     try {
35528       (arg1)->SetMaximumTouchesRequired(arg2);
35529     } catch (std::out_of_range& e) {
35530       {
35531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35532       };
35533     } catch (std::exception& e) {
35534       {
35535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35536       };
35537     } catch (...) {
35538       {
35539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35540       };
35541     }
35542   }
35543 }
35544
35545
35546 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
35547   unsigned int jresult ;
35548   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35549   unsigned int result;
35550
35551   arg1 = (Dali::PanGestureDetector *)jarg1;
35552   {
35553     try {
35554       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
35555     } catch (std::out_of_range& e) {
35556       {
35557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35558       };
35559     } catch (std::exception& e) {
35560       {
35561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35562       };
35563     } catch (...) {
35564       {
35565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35566       };
35567     }
35568   }
35569   jresult = result;
35570   return jresult;
35571 }
35572
35573
35574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
35575   unsigned int jresult ;
35576   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35577   unsigned int result;
35578
35579   arg1 = (Dali::PanGestureDetector *)jarg1;
35580   {
35581     try {
35582       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
35583     } catch (std::out_of_range& e) {
35584       {
35585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35586       };
35587     } catch (std::exception& e) {
35588       {
35589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35590       };
35591     } catch (...) {
35592       {
35593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35594       };
35595     }
35596   }
35597   jresult = result;
35598   return jresult;
35599 }
35600
35601
35602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35603   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35604   Dali::Radian arg2 ;
35605   Dali::Radian arg3 ;
35606   Dali::Radian *argp2 ;
35607   Dali::Radian *argp3 ;
35608
35609   arg1 = (Dali::PanGestureDetector *)jarg1;
35610   argp2 = (Dali::Radian *)jarg2;
35611   if (!argp2) {
35612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35613     return ;
35614   }
35615   arg2 = *argp2;
35616   argp3 = (Dali::Radian *)jarg3;
35617   if (!argp3) {
35618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35619     return ;
35620   }
35621   arg3 = *argp3;
35622   {
35623     try {
35624       (arg1)->AddAngle(arg2,arg3);
35625     } catch (std::out_of_range& e) {
35626       {
35627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35628       };
35629     } catch (std::exception& e) {
35630       {
35631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35632       };
35633     } catch (...) {
35634       {
35635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35636       };
35637     }
35638   }
35639 }
35640
35641
35642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
35643   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35644   Dali::Radian arg2 ;
35645   Dali::Radian *argp2 ;
35646
35647   arg1 = (Dali::PanGestureDetector *)jarg1;
35648   argp2 = (Dali::Radian *)jarg2;
35649   if (!argp2) {
35650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35651     return ;
35652   }
35653   arg2 = *argp2;
35654   {
35655     try {
35656       (arg1)->AddAngle(arg2);
35657     } catch (std::out_of_range& e) {
35658       {
35659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35660       };
35661     } catch (std::exception& e) {
35662       {
35663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35664       };
35665     } catch (...) {
35666       {
35667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35668       };
35669     }
35670   }
35671 }
35672
35673
35674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35675   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35676   Dali::Radian arg2 ;
35677   Dali::Radian arg3 ;
35678   Dali::Radian *argp2 ;
35679   Dali::Radian *argp3 ;
35680
35681   arg1 = (Dali::PanGestureDetector *)jarg1;
35682   argp2 = (Dali::Radian *)jarg2;
35683   if (!argp2) {
35684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35685     return ;
35686   }
35687   arg2 = *argp2;
35688   argp3 = (Dali::Radian *)jarg3;
35689   if (!argp3) {
35690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35691     return ;
35692   }
35693   arg3 = *argp3;
35694   {
35695     try {
35696       (arg1)->AddDirection(arg2,arg3);
35697     } catch (std::out_of_range& e) {
35698       {
35699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35700       };
35701     } catch (std::exception& e) {
35702       {
35703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35704       };
35705     } catch (...) {
35706       {
35707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35708       };
35709     }
35710   }
35711 }
35712
35713
35714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
35715   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35716   Dali::Radian arg2 ;
35717   Dali::Radian *argp2 ;
35718
35719   arg1 = (Dali::PanGestureDetector *)jarg1;
35720   argp2 = (Dali::Radian *)jarg2;
35721   if (!argp2) {
35722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35723     return ;
35724   }
35725   arg2 = *argp2;
35726   {
35727     try {
35728       (arg1)->AddDirection(arg2);
35729     } catch (std::out_of_range& e) {
35730       {
35731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35732       };
35733     } catch (std::exception& e) {
35734       {
35735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35736       };
35737     } catch (...) {
35738       {
35739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35740       };
35741     }
35742   }
35743 }
35744
35745
35746 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
35747   unsigned long jresult ;
35748   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35749   size_t result;
35750
35751   arg1 = (Dali::PanGestureDetector *)jarg1;
35752   {
35753     try {
35754       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
35755     } catch (std::out_of_range& e) {
35756       {
35757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35758       };
35759     } catch (std::exception& e) {
35760       {
35761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35762       };
35763     } catch (...) {
35764       {
35765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35766       };
35767     }
35768   }
35769   jresult = (unsigned long)result;
35770   return jresult;
35771 }
35772
35773
35774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
35775   void * jresult ;
35776   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35777   size_t arg2 ;
35778   Dali::PanGestureDetector::AngleThresholdPair result;
35779
35780   arg1 = (Dali::PanGestureDetector *)jarg1;
35781   arg2 = (size_t)jarg2;
35782   {
35783     try {
35784       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
35785     } catch (std::out_of_range& e) {
35786       {
35787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35788       };
35789     } catch (std::exception& e) {
35790       {
35791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35792       };
35793     } catch (...) {
35794       {
35795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35796       };
35797     }
35798   }
35799   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
35800   return jresult;
35801 }
35802
35803
35804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
35805   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35806
35807   arg1 = (Dali::PanGestureDetector *)jarg1;
35808   {
35809     try {
35810       (arg1)->ClearAngles();
35811     } catch (std::out_of_range& e) {
35812       {
35813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35814       };
35815     } catch (std::exception& e) {
35816       {
35817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35818       };
35819     } catch (...) {
35820       {
35821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35822       };
35823     }
35824   }
35825 }
35826
35827
35828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
35829   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35830   Dali::Radian arg2 ;
35831   Dali::Radian *argp2 ;
35832
35833   arg1 = (Dali::PanGestureDetector *)jarg1;
35834   argp2 = (Dali::Radian *)jarg2;
35835   if (!argp2) {
35836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35837     return ;
35838   }
35839   arg2 = *argp2;
35840   {
35841     try {
35842       (arg1)->RemoveAngle(arg2);
35843     } catch (std::out_of_range& e) {
35844       {
35845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35846       };
35847     } catch (std::exception& e) {
35848       {
35849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35850       };
35851     } catch (...) {
35852       {
35853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35854       };
35855     }
35856   }
35857 }
35858
35859
35860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
35861   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35862   Dali::Radian arg2 ;
35863   Dali::Radian *argp2 ;
35864
35865   arg1 = (Dali::PanGestureDetector *)jarg1;
35866   argp2 = (Dali::Radian *)jarg2;
35867   if (!argp2) {
35868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35869     return ;
35870   }
35871   arg2 = *argp2;
35872   {
35873     try {
35874       (arg1)->RemoveDirection(arg2);
35875     } catch (std::out_of_range& e) {
35876       {
35877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35878       };
35879     } catch (std::exception& e) {
35880       {
35881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35882       };
35883     } catch (...) {
35884       {
35885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35886       };
35887     }
35888   }
35889 }
35890
35891
35892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
35893   void * jresult ;
35894   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35895   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
35896
35897   arg1 = (Dali::PanGestureDetector *)jarg1;
35898   {
35899     try {
35900       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
35901     } catch (std::out_of_range& e) {
35902       {
35903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35904       };
35905     } catch (std::exception& e) {
35906       {
35907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35908       };
35909     } catch (...) {
35910       {
35911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35912       };
35913     }
35914   }
35915   jresult = (void *)result;
35916   return jresult;
35917 }
35918
35919
35920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
35921   Dali::PanGesture *arg1 = 0 ;
35922
35923   arg1 = (Dali::PanGesture *)jarg1;
35924   if (!arg1) {
35925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
35926     return ;
35927   }
35928   {
35929     try {
35930       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
35931     } catch (std::out_of_range& e) {
35932       {
35933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35934       };
35935     } catch (std::exception& e) {
35936       {
35937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35938       };
35939     } catch (...) {
35940       {
35941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35942       };
35943     }
35944   }
35945 }
35946
35947
35948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
35949   void * jresult ;
35950   Dali::PanGesture *result = 0 ;
35951
35952   {
35953     try {
35954       result = (Dali::PanGesture *)new Dali::PanGesture();
35955     } catch (std::out_of_range& e) {
35956       {
35957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35958       };
35959     } catch (std::exception& e) {
35960       {
35961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35962       };
35963     } catch (...) {
35964       {
35965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35966       };
35967     }
35968   }
35969   jresult = (void *)result;
35970   return jresult;
35971 }
35972
35973
35974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
35975   void * jresult ;
35976   Dali::Gesture::State arg1 ;
35977   Dali::PanGesture *result = 0 ;
35978
35979   arg1 = (Dali::Gesture::State)jarg1;
35980   {
35981     try {
35982       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
35983     } catch (std::out_of_range& e) {
35984       {
35985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35986       };
35987     } catch (std::exception& e) {
35988       {
35989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35990       };
35991     } catch (...) {
35992       {
35993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35994       };
35995     }
35996   }
35997   jresult = (void *)result;
35998   return jresult;
35999 }
36000
36001
36002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
36003   void * jresult ;
36004   Dali::PanGesture *arg1 = 0 ;
36005   Dali::PanGesture *result = 0 ;
36006
36007   arg1 = (Dali::PanGesture *)jarg1;
36008   if (!arg1) {
36009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36010     return 0;
36011   }
36012   {
36013     try {
36014       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
36015     } catch (std::out_of_range& e) {
36016       {
36017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36018       };
36019     } catch (std::exception& e) {
36020       {
36021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36022       };
36023     } catch (...) {
36024       {
36025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36026       };
36027     }
36028   }
36029   jresult = (void *)result;
36030   return jresult;
36031 }
36032
36033
36034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
36035   void * jresult ;
36036   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36037   Dali::PanGesture *arg2 = 0 ;
36038   Dali::PanGesture *result = 0 ;
36039
36040   arg1 = (Dali::PanGesture *)jarg1;
36041   arg2 = (Dali::PanGesture *)jarg2;
36042   if (!arg2) {
36043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36044     return 0;
36045   }
36046   {
36047     try {
36048       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
36049     } catch (std::out_of_range& e) {
36050       {
36051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36052       };
36053     } catch (std::exception& e) {
36054       {
36055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36056       };
36057     } catch (...) {
36058       {
36059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36060       };
36061     }
36062   }
36063   jresult = (void *)result;
36064   return jresult;
36065 }
36066
36067
36068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
36069   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36070
36071   arg1 = (Dali::PanGesture *)jarg1;
36072   {
36073     try {
36074       delete arg1;
36075     } catch (std::out_of_range& e) {
36076       {
36077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36078       };
36079     } catch (std::exception& e) {
36080       {
36081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36082       };
36083     } catch (...) {
36084       {
36085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36086       };
36087     }
36088   }
36089 }
36090
36091
36092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
36093   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36094   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36095
36096   arg1 = (Dali::PanGesture *)jarg1;
36097   arg2 = (Dali::Vector2 *)jarg2;
36098   if (arg1) (arg1)->velocity = *arg2;
36099 }
36100
36101
36102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
36103   void * jresult ;
36104   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36105   Dali::Vector2 *result = 0 ;
36106
36107   arg1 = (Dali::PanGesture *)jarg1;
36108   result = (Dali::Vector2 *)& ((arg1)->velocity);
36109   jresult = (void *)result;
36110   return jresult;
36111 }
36112
36113
36114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
36115   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36116   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36117
36118   arg1 = (Dali::PanGesture *)jarg1;
36119   arg2 = (Dali::Vector2 *)jarg2;
36120   if (arg1) (arg1)->displacement = *arg2;
36121 }
36122
36123
36124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
36125   void * jresult ;
36126   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36127   Dali::Vector2 *result = 0 ;
36128
36129   arg1 = (Dali::PanGesture *)jarg1;
36130   result = (Dali::Vector2 *)& ((arg1)->displacement);
36131   jresult = (void *)result;
36132   return jresult;
36133 }
36134
36135
36136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
36137   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36138   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36139
36140   arg1 = (Dali::PanGesture *)jarg1;
36141   arg2 = (Dali::Vector2 *)jarg2;
36142   if (arg1) (arg1)->position = *arg2;
36143 }
36144
36145
36146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
36147   void * jresult ;
36148   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36149   Dali::Vector2 *result = 0 ;
36150
36151   arg1 = (Dali::PanGesture *)jarg1;
36152   result = (Dali::Vector2 *)& ((arg1)->position);
36153   jresult = (void *)result;
36154   return jresult;
36155 }
36156
36157
36158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
36159   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36160   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36161
36162   arg1 = (Dali::PanGesture *)jarg1;
36163   arg2 = (Dali::Vector2 *)jarg2;
36164   if (arg1) (arg1)->screenVelocity = *arg2;
36165 }
36166
36167
36168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
36169   void * jresult ;
36170   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36171   Dali::Vector2 *result = 0 ;
36172
36173   arg1 = (Dali::PanGesture *)jarg1;
36174   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
36175   jresult = (void *)result;
36176   return jresult;
36177 }
36178
36179
36180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
36181   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36182   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36183
36184   arg1 = (Dali::PanGesture *)jarg1;
36185   arg2 = (Dali::Vector2 *)jarg2;
36186   if (arg1) (arg1)->screenDisplacement = *arg2;
36187 }
36188
36189
36190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
36191   void * jresult ;
36192   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36193   Dali::Vector2 *result = 0 ;
36194
36195   arg1 = (Dali::PanGesture *)jarg1;
36196   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
36197   jresult = (void *)result;
36198   return jresult;
36199 }
36200
36201
36202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
36203   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36204   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36205
36206   arg1 = (Dali::PanGesture *)jarg1;
36207   arg2 = (Dali::Vector2 *)jarg2;
36208   if (arg1) (arg1)->screenPosition = *arg2;
36209 }
36210
36211
36212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
36213   void * jresult ;
36214   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36215   Dali::Vector2 *result = 0 ;
36216
36217   arg1 = (Dali::PanGesture *)jarg1;
36218   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
36219   jresult = (void *)result;
36220   return jresult;
36221 }
36222
36223
36224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
36225   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36226   unsigned int arg2 ;
36227
36228   arg1 = (Dali::PanGesture *)jarg1;
36229   arg2 = (unsigned int)jarg2;
36230   if (arg1) (arg1)->numberOfTouches = arg2;
36231 }
36232
36233
36234 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
36235   unsigned int jresult ;
36236   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36237   unsigned int result;
36238
36239   arg1 = (Dali::PanGesture *)jarg1;
36240   result = (unsigned int) ((arg1)->numberOfTouches);
36241   jresult = result;
36242   return jresult;
36243 }
36244
36245
36246 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
36247   float jresult ;
36248   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36249   float result;
36250
36251   arg1 = (Dali::PanGesture *)jarg1;
36252   {
36253     try {
36254       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
36255     } catch (std::out_of_range& e) {
36256       {
36257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36258       };
36259     } catch (std::exception& e) {
36260       {
36261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36262       };
36263     } catch (...) {
36264       {
36265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36266       };
36267     }
36268   }
36269   jresult = result;
36270   return jresult;
36271 }
36272
36273
36274 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
36275   float jresult ;
36276   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36277   float result;
36278
36279   arg1 = (Dali::PanGesture *)jarg1;
36280   {
36281     try {
36282       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
36283     } catch (std::out_of_range& e) {
36284       {
36285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36286       };
36287     } catch (std::exception& e) {
36288       {
36289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36290       };
36291     } catch (...) {
36292       {
36293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36294       };
36295     }
36296   }
36297   jresult = result;
36298   return jresult;
36299 }
36300
36301
36302 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
36303   float jresult ;
36304   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36305   float result;
36306
36307   arg1 = (Dali::PanGesture *)jarg1;
36308   {
36309     try {
36310       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
36311     } catch (std::out_of_range& e) {
36312       {
36313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36314       };
36315     } catch (std::exception& e) {
36316       {
36317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36318       };
36319     } catch (...) {
36320       {
36321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36322       };
36323     }
36324   }
36325   jresult = result;
36326   return jresult;
36327 }
36328
36329
36330 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
36331   float jresult ;
36332   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36333   float result;
36334
36335   arg1 = (Dali::PanGesture *)jarg1;
36336   {
36337     try {
36338       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
36339     } catch (std::out_of_range& e) {
36340       {
36341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36342       };
36343     } catch (std::exception& e) {
36344       {
36345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36346       };
36347     } catch (...) {
36348       {
36349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36350       };
36351     }
36352   }
36353   jresult = result;
36354   return jresult;
36355 }
36356
36357
36358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
36359   void * jresult ;
36360   Dali::PinchGestureDetector *result = 0 ;
36361
36362   {
36363     try {
36364       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
36365     } catch (std::out_of_range& e) {
36366       {
36367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36368       };
36369     } catch (std::exception& e) {
36370       {
36371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36372       };
36373     } catch (...) {
36374       {
36375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36376       };
36377     }
36378   }
36379   jresult = (void *)result;
36380   return jresult;
36381 }
36382
36383
36384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
36385   void * jresult ;
36386   Dali::PinchGestureDetector result;
36387
36388   {
36389     try {
36390       result = Dali::PinchGestureDetector::New();
36391     } catch (std::out_of_range& e) {
36392       {
36393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36394       };
36395     } catch (std::exception& e) {
36396       {
36397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36398       };
36399     } catch (...) {
36400       {
36401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36402       };
36403     }
36404   }
36405   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36406   return jresult;
36407 }
36408
36409
36410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
36411   void * jresult ;
36412   Dali::BaseHandle arg1 ;
36413   Dali::BaseHandle *argp1 ;
36414   Dali::PinchGestureDetector result;
36415
36416   argp1 = (Dali::BaseHandle *)jarg1;
36417   if (!argp1) {
36418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36419     return 0;
36420   }
36421   arg1 = *argp1;
36422   {
36423     try {
36424       result = Dali::PinchGestureDetector::DownCast(arg1);
36425     } catch (std::out_of_range& e) {
36426       {
36427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36428       };
36429     } catch (std::exception& e) {
36430       {
36431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36432       };
36433     } catch (...) {
36434       {
36435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36436       };
36437     }
36438   }
36439   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36440   return jresult;
36441 }
36442
36443
36444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
36445   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36446
36447   arg1 = (Dali::PinchGestureDetector *)jarg1;
36448   {
36449     try {
36450       delete arg1;
36451     } catch (std::out_of_range& e) {
36452       {
36453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36454       };
36455     } catch (std::exception& e) {
36456       {
36457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36458       };
36459     } catch (...) {
36460       {
36461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36462       };
36463     }
36464   }
36465 }
36466
36467
36468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
36469   void * jresult ;
36470   Dali::PinchGestureDetector *arg1 = 0 ;
36471   Dali::PinchGestureDetector *result = 0 ;
36472
36473   arg1 = (Dali::PinchGestureDetector *)jarg1;
36474   if (!arg1) {
36475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36476     return 0;
36477   }
36478   {
36479     try {
36480       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
36481     } catch (std::out_of_range& e) {
36482       {
36483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36484       };
36485     } catch (std::exception& e) {
36486       {
36487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36488       };
36489     } catch (...) {
36490       {
36491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36492       };
36493     }
36494   }
36495   jresult = (void *)result;
36496   return jresult;
36497 }
36498
36499
36500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
36501   void * jresult ;
36502   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36503   Dali::PinchGestureDetector *arg2 = 0 ;
36504   Dali::PinchGestureDetector *result = 0 ;
36505
36506   arg1 = (Dali::PinchGestureDetector *)jarg1;
36507   arg2 = (Dali::PinchGestureDetector *)jarg2;
36508   if (!arg2) {
36509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36510     return 0;
36511   }
36512   {
36513     try {
36514       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
36515     } catch (std::out_of_range& e) {
36516       {
36517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36518       };
36519     } catch (std::exception& e) {
36520       {
36521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36522       };
36523     } catch (...) {
36524       {
36525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36526       };
36527     }
36528   }
36529   jresult = (void *)result;
36530   return jresult;
36531 }
36532
36533
36534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
36535   void * jresult ;
36536   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36537   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
36538
36539   arg1 = (Dali::PinchGestureDetector *)jarg1;
36540   {
36541     try {
36542       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
36543     } catch (std::out_of_range& e) {
36544       {
36545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36546       };
36547     } catch (std::exception& e) {
36548       {
36549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36550       };
36551     } catch (...) {
36552       {
36553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36554       };
36555     }
36556   }
36557   jresult = (void *)result;
36558   return jresult;
36559 }
36560
36561
36562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
36563   void * jresult ;
36564   Dali::Gesture::State arg1 ;
36565   Dali::PinchGesture *result = 0 ;
36566
36567   arg1 = (Dali::Gesture::State)jarg1;
36568   {
36569     try {
36570       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
36571     } catch (std::out_of_range& e) {
36572       {
36573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36574       };
36575     } catch (std::exception& e) {
36576       {
36577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36578       };
36579     } catch (...) {
36580       {
36581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36582       };
36583     }
36584   }
36585   jresult = (void *)result;
36586   return jresult;
36587 }
36588
36589
36590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
36591   void * jresult ;
36592   Dali::PinchGesture *arg1 = 0 ;
36593   Dali::PinchGesture *result = 0 ;
36594
36595   arg1 = (Dali::PinchGesture *)jarg1;
36596   if (!arg1) {
36597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36598     return 0;
36599   }
36600   {
36601     try {
36602       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
36603     } catch (std::out_of_range& e) {
36604       {
36605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36606       };
36607     } catch (std::exception& e) {
36608       {
36609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36610       };
36611     } catch (...) {
36612       {
36613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36614       };
36615     }
36616   }
36617   jresult = (void *)result;
36618   return jresult;
36619 }
36620
36621
36622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
36623   void * jresult ;
36624   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36625   Dali::PinchGesture *arg2 = 0 ;
36626   Dali::PinchGesture *result = 0 ;
36627
36628   arg1 = (Dali::PinchGesture *)jarg1;
36629   arg2 = (Dali::PinchGesture *)jarg2;
36630   if (!arg2) {
36631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36632     return 0;
36633   }
36634   {
36635     try {
36636       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
36637     } catch (std::out_of_range& e) {
36638       {
36639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36640       };
36641     } catch (std::exception& e) {
36642       {
36643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36644       };
36645     } catch (...) {
36646       {
36647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36648       };
36649     }
36650   }
36651   jresult = (void *)result;
36652   return jresult;
36653 }
36654
36655
36656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
36657   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36658
36659   arg1 = (Dali::PinchGesture *)jarg1;
36660   {
36661     try {
36662       delete arg1;
36663     } catch (std::out_of_range& e) {
36664       {
36665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36666       };
36667     } catch (std::exception& e) {
36668       {
36669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36670       };
36671     } catch (...) {
36672       {
36673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36674       };
36675     }
36676   }
36677 }
36678
36679
36680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
36681   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36682   float arg2 ;
36683
36684   arg1 = (Dali::PinchGesture *)jarg1;
36685   arg2 = (float)jarg2;
36686   if (arg1) (arg1)->scale = arg2;
36687 }
36688
36689
36690 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
36691   float jresult ;
36692   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36693   float result;
36694
36695   arg1 = (Dali::PinchGesture *)jarg1;
36696   result = (float) ((arg1)->scale);
36697   jresult = result;
36698   return jresult;
36699 }
36700
36701
36702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
36703   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36704   float arg2 ;
36705
36706   arg1 = (Dali::PinchGesture *)jarg1;
36707   arg2 = (float)jarg2;
36708   if (arg1) (arg1)->speed = arg2;
36709 }
36710
36711
36712 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
36713   float jresult ;
36714   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36715   float result;
36716
36717   arg1 = (Dali::PinchGesture *)jarg1;
36718   result = (float) ((arg1)->speed);
36719   jresult = result;
36720   return jresult;
36721 }
36722
36723
36724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
36725   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36726   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36727
36728   arg1 = (Dali::PinchGesture *)jarg1;
36729   arg2 = (Dali::Vector2 *)jarg2;
36730   if (arg1) (arg1)->screenCenterPoint = *arg2;
36731 }
36732
36733
36734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
36735   void * jresult ;
36736   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36737   Dali::Vector2 *result = 0 ;
36738
36739   arg1 = (Dali::PinchGesture *)jarg1;
36740   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
36741   jresult = (void *)result;
36742   return jresult;
36743 }
36744
36745
36746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
36747   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36748   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36749
36750   arg1 = (Dali::PinchGesture *)jarg1;
36751   arg2 = (Dali::Vector2 *)jarg2;
36752   if (arg1) (arg1)->localCenterPoint = *arg2;
36753 }
36754
36755
36756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
36757   void * jresult ;
36758   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36759   Dali::Vector2 *result = 0 ;
36760
36761   arg1 = (Dali::PinchGesture *)jarg1;
36762   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
36763   jresult = (void *)result;
36764   return jresult;
36765 }
36766
36767
36768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
36769   void * jresult ;
36770   Dali::TapGestureDetector *result = 0 ;
36771
36772   {
36773     try {
36774       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
36775     } catch (std::out_of_range& e) {
36776       {
36777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36778       };
36779     } catch (std::exception& e) {
36780       {
36781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36782       };
36783     } catch (...) {
36784       {
36785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36786       };
36787     }
36788   }
36789   jresult = (void *)result;
36790   return jresult;
36791 }
36792
36793
36794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
36795   void * jresult ;
36796   Dali::TapGestureDetector result;
36797
36798   {
36799     try {
36800       result = Dali::TapGestureDetector::New();
36801     } catch (std::out_of_range& e) {
36802       {
36803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36804       };
36805     } catch (std::exception& e) {
36806       {
36807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36808       };
36809     } catch (...) {
36810       {
36811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36812       };
36813     }
36814   }
36815   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36816   return jresult;
36817 }
36818
36819
36820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
36821   void * jresult ;
36822   unsigned int arg1 ;
36823   Dali::TapGestureDetector result;
36824
36825   arg1 = (unsigned int)jarg1;
36826   {
36827     try {
36828       result = Dali::TapGestureDetector::New(arg1);
36829     } catch (std::out_of_range& e) {
36830       {
36831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36832       };
36833     } catch (std::exception& e) {
36834       {
36835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36836       };
36837     } catch (...) {
36838       {
36839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36840       };
36841     }
36842   }
36843   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36844   return jresult;
36845 }
36846
36847
36848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
36849   void * jresult ;
36850   Dali::BaseHandle arg1 ;
36851   Dali::BaseHandle *argp1 ;
36852   Dali::TapGestureDetector result;
36853
36854   argp1 = (Dali::BaseHandle *)jarg1;
36855   if (!argp1) {
36856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36857     return 0;
36858   }
36859   arg1 = *argp1;
36860   {
36861     try {
36862       result = Dali::TapGestureDetector::DownCast(arg1);
36863     } catch (std::out_of_range& e) {
36864       {
36865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36866       };
36867     } catch (std::exception& e) {
36868       {
36869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36870       };
36871     } catch (...) {
36872       {
36873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36874       };
36875     }
36876   }
36877   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36878   return jresult;
36879 }
36880
36881
36882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
36883   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36884
36885   arg1 = (Dali::TapGestureDetector *)jarg1;
36886   {
36887     try {
36888       delete arg1;
36889     } catch (std::out_of_range& e) {
36890       {
36891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36892       };
36893     } catch (std::exception& e) {
36894       {
36895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36896       };
36897     } catch (...) {
36898       {
36899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36900       };
36901     }
36902   }
36903 }
36904
36905
36906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
36907   void * jresult ;
36908   Dali::TapGestureDetector *arg1 = 0 ;
36909   Dali::TapGestureDetector *result = 0 ;
36910
36911   arg1 = (Dali::TapGestureDetector *)jarg1;
36912   if (!arg1) {
36913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
36914     return 0;
36915   }
36916   {
36917     try {
36918       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
36919     } catch (std::out_of_range& e) {
36920       {
36921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36922       };
36923     } catch (std::exception& e) {
36924       {
36925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36926       };
36927     } catch (...) {
36928       {
36929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36930       };
36931     }
36932   }
36933   jresult = (void *)result;
36934   return jresult;
36935 }
36936
36937
36938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
36939   void * jresult ;
36940   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36941   Dali::TapGestureDetector *arg2 = 0 ;
36942   Dali::TapGestureDetector *result = 0 ;
36943
36944   arg1 = (Dali::TapGestureDetector *)jarg1;
36945   arg2 = (Dali::TapGestureDetector *)jarg2;
36946   if (!arg2) {
36947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
36948     return 0;
36949   }
36950   {
36951     try {
36952       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
36953     } catch (std::out_of_range& e) {
36954       {
36955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36956       };
36957     } catch (std::exception& e) {
36958       {
36959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36960       };
36961     } catch (...) {
36962       {
36963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36964       };
36965     }
36966   }
36967   jresult = (void *)result;
36968   return jresult;
36969 }
36970
36971
36972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
36973   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36974   unsigned int arg2 ;
36975
36976   arg1 = (Dali::TapGestureDetector *)jarg1;
36977   arg2 = (unsigned int)jarg2;
36978   {
36979     try {
36980       (arg1)->SetMinimumTapsRequired(arg2);
36981     } catch (std::out_of_range& e) {
36982       {
36983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36984       };
36985     } catch (std::exception& e) {
36986       {
36987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36988       };
36989     } catch (...) {
36990       {
36991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36992       };
36993     }
36994   }
36995 }
36996
36997
36998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
36999   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37000   unsigned int arg2 ;
37001
37002   arg1 = (Dali::TapGestureDetector *)jarg1;
37003   arg2 = (unsigned int)jarg2;
37004   {
37005     try {
37006       (arg1)->SetMaximumTapsRequired(arg2);
37007     } catch (std::out_of_range& e) {
37008       {
37009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37010       };
37011     } catch (std::exception& e) {
37012       {
37013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37014       };
37015     } catch (...) {
37016       {
37017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37018       };
37019     }
37020   }
37021 }
37022
37023
37024 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
37025   unsigned int jresult ;
37026   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37027   unsigned int result;
37028
37029   arg1 = (Dali::TapGestureDetector *)jarg1;
37030   {
37031     try {
37032       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
37033     } catch (std::out_of_range& e) {
37034       {
37035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37036       };
37037     } catch (std::exception& e) {
37038       {
37039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37040       };
37041     } catch (...) {
37042       {
37043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37044       };
37045     }
37046   }
37047   jresult = result;
37048   return jresult;
37049 }
37050
37051
37052 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
37053   unsigned int jresult ;
37054   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37055   unsigned int result;
37056
37057   arg1 = (Dali::TapGestureDetector *)jarg1;
37058   {
37059     try {
37060       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
37061     } catch (std::out_of_range& e) {
37062       {
37063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37064       };
37065     } catch (std::exception& e) {
37066       {
37067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37068       };
37069     } catch (...) {
37070       {
37071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37072       };
37073     }
37074   }
37075   jresult = result;
37076   return jresult;
37077 }
37078
37079
37080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
37081   void * jresult ;
37082   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37083   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
37084
37085   arg1 = (Dali::TapGestureDetector *)jarg1;
37086   {
37087     try {
37088       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
37089     } catch (std::out_of_range& e) {
37090       {
37091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37092       };
37093     } catch (std::exception& e) {
37094       {
37095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37096       };
37097     } catch (...) {
37098       {
37099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37100       };
37101     }
37102   }
37103   jresult = (void *)result;
37104   return jresult;
37105 }
37106
37107
37108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
37109   void * jresult ;
37110   Dali::TapGesture *result = 0 ;
37111
37112   {
37113     try {
37114       result = (Dali::TapGesture *)new Dali::TapGesture();
37115     } catch (std::out_of_range& e) {
37116       {
37117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37118       };
37119     } catch (std::exception& e) {
37120       {
37121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37122       };
37123     } catch (...) {
37124       {
37125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37126       };
37127     }
37128   }
37129   jresult = (void *)result;
37130   return jresult;
37131 }
37132
37133
37134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
37135   void * jresult ;
37136   Dali::TapGesture *arg1 = 0 ;
37137   Dali::TapGesture *result = 0 ;
37138
37139   arg1 = (Dali::TapGesture *)jarg1;
37140   if (!arg1) {
37141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37142     return 0;
37143   }
37144   {
37145     try {
37146       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
37147     } catch (std::out_of_range& e) {
37148       {
37149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37150       };
37151     } catch (std::exception& e) {
37152       {
37153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37154       };
37155     } catch (...) {
37156       {
37157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37158       };
37159     }
37160   }
37161   jresult = (void *)result;
37162   return jresult;
37163 }
37164
37165
37166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
37167   void * jresult ;
37168   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37169   Dali::TapGesture *arg2 = 0 ;
37170   Dali::TapGesture *result = 0 ;
37171
37172   arg1 = (Dali::TapGesture *)jarg1;
37173   arg2 = (Dali::TapGesture *)jarg2;
37174   if (!arg2) {
37175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37176     return 0;
37177   }
37178   {
37179     try {
37180       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
37181     } catch (std::out_of_range& e) {
37182       {
37183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37184       };
37185     } catch (std::exception& e) {
37186       {
37187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37188       };
37189     } catch (...) {
37190       {
37191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37192       };
37193     }
37194   }
37195   jresult = (void *)result;
37196   return jresult;
37197 }
37198
37199
37200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
37201   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37202
37203   arg1 = (Dali::TapGesture *)jarg1;
37204   {
37205     try {
37206       delete arg1;
37207     } catch (std::out_of_range& e) {
37208       {
37209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37210       };
37211     } catch (std::exception& e) {
37212       {
37213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37214       };
37215     } catch (...) {
37216       {
37217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37218       };
37219     }
37220   }
37221 }
37222
37223
37224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
37225   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37226   unsigned int arg2 ;
37227
37228   arg1 = (Dali::TapGesture *)jarg1;
37229   arg2 = (unsigned int)jarg2;
37230   if (arg1) (arg1)->numberOfTaps = arg2;
37231 }
37232
37233
37234 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
37235   unsigned int jresult ;
37236   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37237   unsigned int result;
37238
37239   arg1 = (Dali::TapGesture *)jarg1;
37240   result = (unsigned int) ((arg1)->numberOfTaps);
37241   jresult = result;
37242   return jresult;
37243 }
37244
37245
37246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
37247   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37248   unsigned int arg2 ;
37249
37250   arg1 = (Dali::TapGesture *)jarg1;
37251   arg2 = (unsigned int)jarg2;
37252   if (arg1) (arg1)->numberOfTouches = arg2;
37253 }
37254
37255
37256 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
37257   unsigned int jresult ;
37258   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37259   unsigned int result;
37260
37261   arg1 = (Dali::TapGesture *)jarg1;
37262   result = (unsigned int) ((arg1)->numberOfTouches);
37263   jresult = result;
37264   return jresult;
37265 }
37266
37267
37268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
37269   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37270   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37271
37272   arg1 = (Dali::TapGesture *)jarg1;
37273   arg2 = (Dali::Vector2 *)jarg2;
37274   if (arg1) (arg1)->screenPoint = *arg2;
37275 }
37276
37277
37278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
37279   void * jresult ;
37280   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37281   Dali::Vector2 *result = 0 ;
37282
37283   arg1 = (Dali::TapGesture *)jarg1;
37284   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
37285   jresult = (void *)result;
37286   return jresult;
37287 }
37288
37289
37290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
37291   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37292   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37293
37294   arg1 = (Dali::TapGesture *)jarg1;
37295   arg2 = (Dali::Vector2 *)jarg2;
37296   if (arg1) (arg1)->localPoint = *arg2;
37297 }
37298
37299
37300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
37301   void * jresult ;
37302   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37303   Dali::Vector2 *result = 0 ;
37304
37305   arg1 = (Dali::TapGesture *)jarg1;
37306   result = (Dali::Vector2 *)& ((arg1)->localPoint);
37307   jresult = (void *)result;
37308   return jresult;
37309 }
37310
37311
37312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
37313   void * jresult ;
37314   Dali::AlphaFunction *result = 0 ;
37315
37316   {
37317     try {
37318       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
37319     } catch (std::out_of_range& e) {
37320       {
37321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37322       };
37323     } catch (std::exception& e) {
37324       {
37325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37326       };
37327     } catch (...) {
37328       {
37329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37330       };
37331     }
37332   }
37333   jresult = (void *)result;
37334   return jresult;
37335 }
37336
37337
37338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
37339   void * jresult ;
37340   Dali::AlphaFunction::BuiltinFunction arg1 ;
37341   Dali::AlphaFunction *result = 0 ;
37342
37343   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
37344   {
37345     try {
37346       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37347     } catch (std::out_of_range& e) {
37348       {
37349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37350       };
37351     } catch (std::exception& e) {
37352       {
37353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37354       };
37355     } catch (...) {
37356       {
37357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37358       };
37359     }
37360   }
37361   jresult = (void *)result;
37362   return jresult;
37363 }
37364
37365
37366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
37367   void * jresult ;
37368   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
37369   Dali::AlphaFunction *result = 0 ;
37370
37371   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
37372   {
37373     try {
37374       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37375     } catch (std::out_of_range& e) {
37376       {
37377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37378       };
37379     } catch (std::exception& e) {
37380       {
37381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37382       };
37383     } catch (...) {
37384       {
37385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37386       };
37387     }
37388   }
37389   jresult = (void *)result;
37390   return jresult;
37391 }
37392
37393
37394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
37395   void * jresult ;
37396   Dali::Vector2 *arg1 = 0 ;
37397   Dali::Vector2 *arg2 = 0 ;
37398   Dali::AlphaFunction *result = 0 ;
37399
37400   arg1 = (Dali::Vector2 *)jarg1;
37401   if (!arg1) {
37402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37403     return 0;
37404   }
37405   arg2 = (Dali::Vector2 *)jarg2;
37406   if (!arg2) {
37407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37408     return 0;
37409   }
37410   {
37411     try {
37412       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
37413     } catch (std::out_of_range& e) {
37414       {
37415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37416       };
37417     } catch (std::exception& e) {
37418       {
37419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37420       };
37421     } catch (...) {
37422       {
37423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37424       };
37425     }
37426   }
37427   jresult = (void *)result;
37428   return jresult;
37429 }
37430
37431
37432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
37433   void * jresult ;
37434   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37435   Dali::Vector4 result;
37436
37437   arg1 = (Dali::AlphaFunction *)jarg1;
37438   {
37439     try {
37440       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
37441     } catch (std::out_of_range& e) {
37442       {
37443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37444       };
37445     } catch (std::exception& e) {
37446       {
37447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37448       };
37449     } catch (...) {
37450       {
37451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37452       };
37453     }
37454   }
37455   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
37456   return jresult;
37457 }
37458
37459
37460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
37461   void * jresult ;
37462   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37463   Dali::AlphaFunctionPrototype result;
37464
37465   arg1 = (Dali::AlphaFunction *)jarg1;
37466   {
37467     try {
37468       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
37469     } catch (std::out_of_range& e) {
37470       {
37471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37472       };
37473     } catch (std::exception& e) {
37474       {
37475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37476       };
37477     } catch (...) {
37478       {
37479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37480       };
37481     }
37482   }
37483   jresult = (void *)result;
37484   return jresult;
37485 }
37486
37487
37488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
37489   int jresult ;
37490   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37491   Dali::AlphaFunction::BuiltinFunction result;
37492
37493   arg1 = (Dali::AlphaFunction *)jarg1;
37494   {
37495     try {
37496       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
37497     } catch (std::out_of_range& e) {
37498       {
37499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37500       };
37501     } catch (std::exception& e) {
37502       {
37503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37504       };
37505     } catch (...) {
37506       {
37507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37508       };
37509     }
37510   }
37511   jresult = (int)result;
37512   return jresult;
37513 }
37514
37515
37516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
37517   int jresult ;
37518   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37519   Dali::AlphaFunction::Mode result;
37520
37521   arg1 = (Dali::AlphaFunction *)jarg1;
37522   {
37523     try {
37524       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
37525     } catch (std::out_of_range& e) {
37526       {
37527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37528       };
37529     } catch (std::exception& e) {
37530       {
37531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37532       };
37533     } catch (...) {
37534       {
37535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37536       };
37537     }
37538   }
37539   jresult = (int)result;
37540   return jresult;
37541 }
37542
37543
37544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
37545   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37546
37547   arg1 = (Dali::AlphaFunction *)jarg1;
37548   {
37549     try {
37550       delete arg1;
37551     } catch (std::out_of_range& e) {
37552       {
37553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37554       };
37555     } catch (std::exception& e) {
37556       {
37557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37558       };
37559     } catch (...) {
37560       {
37561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37562       };
37563     }
37564   }
37565 }
37566
37567
37568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
37569   void * jresult ;
37570   Dali::KeyFrames result;
37571
37572   {
37573     try {
37574       result = Dali::KeyFrames::New();
37575     } catch (std::out_of_range& e) {
37576       {
37577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37578       };
37579     } catch (std::exception& e) {
37580       {
37581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37582       };
37583     } catch (...) {
37584       {
37585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37586       };
37587     }
37588   }
37589   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37590   return jresult;
37591 }
37592
37593
37594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
37595   void * jresult ;
37596   Dali::BaseHandle arg1 ;
37597   Dali::BaseHandle *argp1 ;
37598   Dali::KeyFrames result;
37599
37600   argp1 = (Dali::BaseHandle *)jarg1;
37601   if (!argp1) {
37602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37603     return 0;
37604   }
37605   arg1 = *argp1;
37606   {
37607     try {
37608       result = Dali::KeyFrames::DownCast(arg1);
37609     } catch (std::out_of_range& e) {
37610       {
37611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37612       };
37613     } catch (std::exception& e) {
37614       {
37615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37616       };
37617     } catch (...) {
37618       {
37619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37620       };
37621     }
37622   }
37623   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37624   return jresult;
37625 }
37626
37627
37628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
37629   void * jresult ;
37630   Dali::KeyFrames *result = 0 ;
37631
37632   {
37633     try {
37634       result = (Dali::KeyFrames *)new Dali::KeyFrames();
37635     } catch (std::out_of_range& e) {
37636       {
37637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37638       };
37639     } catch (std::exception& e) {
37640       {
37641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37642       };
37643     } catch (...) {
37644       {
37645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37646       };
37647     }
37648   }
37649   jresult = (void *)result;
37650   return jresult;
37651 }
37652
37653
37654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
37655   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37656
37657   arg1 = (Dali::KeyFrames *)jarg1;
37658   {
37659     try {
37660       delete arg1;
37661     } catch (std::out_of_range& e) {
37662       {
37663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37664       };
37665     } catch (std::exception& e) {
37666       {
37667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37668       };
37669     } catch (...) {
37670       {
37671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37672       };
37673     }
37674   }
37675 }
37676
37677
37678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
37679   void * jresult ;
37680   Dali::KeyFrames *arg1 = 0 ;
37681   Dali::KeyFrames *result = 0 ;
37682
37683   arg1 = (Dali::KeyFrames *)jarg1;
37684   if (!arg1) {
37685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37686     return 0;
37687   }
37688   {
37689     try {
37690       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
37691     } catch (std::out_of_range& e) {
37692       {
37693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37694       };
37695     } catch (std::exception& e) {
37696       {
37697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37698       };
37699     } catch (...) {
37700       {
37701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37702       };
37703     }
37704   }
37705   jresult = (void *)result;
37706   return jresult;
37707 }
37708
37709
37710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
37711   void * jresult ;
37712   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37713   Dali::KeyFrames *arg2 = 0 ;
37714   Dali::KeyFrames *result = 0 ;
37715
37716   arg1 = (Dali::KeyFrames *)jarg1;
37717   arg2 = (Dali::KeyFrames *)jarg2;
37718   if (!arg2) {
37719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37720     return 0;
37721   }
37722   {
37723     try {
37724       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
37725     } catch (std::out_of_range& e) {
37726       {
37727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37728       };
37729     } catch (std::exception& e) {
37730       {
37731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37732       };
37733     } catch (...) {
37734       {
37735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37736       };
37737     }
37738   }
37739   jresult = (void *)result;
37740   return jresult;
37741 }
37742
37743
37744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
37745   int jresult ;
37746   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37747   Dali::Property::Type result;
37748
37749   arg1 = (Dali::KeyFrames *)jarg1;
37750   {
37751     try {
37752       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
37753     } catch (std::out_of_range& e) {
37754       {
37755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37756       };
37757     } catch (std::exception& e) {
37758       {
37759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37760       };
37761     } catch (...) {
37762       {
37763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37764       };
37765     }
37766   }
37767   jresult = (int)result;
37768   return jresult;
37769 }
37770
37771
37772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
37773   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37774   float arg2 ;
37775   Dali::Property::Value arg3 ;
37776   Dali::Property::Value *argp3 ;
37777
37778   arg1 = (Dali::KeyFrames *)jarg1;
37779   arg2 = (float)jarg2;
37780   argp3 = (Dali::Property::Value *)jarg3;
37781   if (!argp3) {
37782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37783     return ;
37784   }
37785   arg3 = *argp3;
37786   {
37787     try {
37788       (arg1)->Add(arg2,arg3);
37789     } catch (std::out_of_range& e) {
37790       {
37791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37792       };
37793     } catch (std::exception& e) {
37794       {
37795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37796       };
37797     } catch (...) {
37798       {
37799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37800       };
37801     }
37802   }
37803 }
37804
37805
37806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
37807   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37808   float arg2 ;
37809   Dali::Property::Value arg3 ;
37810   Dali::AlphaFunction arg4 ;
37811   Dali::Property::Value *argp3 ;
37812   Dali::AlphaFunction *argp4 ;
37813
37814   arg1 = (Dali::KeyFrames *)jarg1;
37815   arg2 = (float)jarg2;
37816   argp3 = (Dali::Property::Value *)jarg3;
37817   if (!argp3) {
37818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37819     return ;
37820   }
37821   arg3 = *argp3;
37822   argp4 = (Dali::AlphaFunction *)jarg4;
37823   if (!argp4) {
37824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
37825     return ;
37826   }
37827   arg4 = *argp4;
37828   {
37829     try {
37830       (arg1)->Add(arg2,arg3,arg4);
37831     } catch (std::out_of_range& e) {
37832       {
37833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37834       };
37835     } catch (std::exception& e) {
37836       {
37837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37838       };
37839     } catch (...) {
37840       {
37841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37842       };
37843     }
37844   }
37845 }
37846
37847
37848 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
37849   int jresult ;
37850   int result;
37851
37852   result = (int)Dali::Path::Property::POINTS;
37853   jresult = (int)result;
37854   return jresult;
37855 }
37856
37857
37858 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
37859   int jresult ;
37860   int result;
37861
37862   result = (int)Dali::Path::Property::CONTROL_POINTS;
37863   jresult = (int)result;
37864   return jresult;
37865 }
37866
37867
37868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
37869   void * jresult ;
37870   Dali::Path::Property *result = 0 ;
37871
37872   {
37873     try {
37874       result = (Dali::Path::Property *)new Dali::Path::Property();
37875     } catch (std::out_of_range& e) {
37876       {
37877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37878       };
37879     } catch (std::exception& e) {
37880       {
37881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37882       };
37883     } catch (...) {
37884       {
37885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37886       };
37887     }
37888   }
37889   jresult = (void *)result;
37890   return jresult;
37891 }
37892
37893
37894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
37895   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
37896
37897   arg1 = (Dali::Path::Property *)jarg1;
37898   {
37899     try {
37900       delete arg1;
37901     } catch (std::out_of_range& e) {
37902       {
37903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37904       };
37905     } catch (std::exception& e) {
37906       {
37907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37908       };
37909     } catch (...) {
37910       {
37911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37912       };
37913     }
37914   }
37915 }
37916
37917
37918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
37919   void * jresult ;
37920   Dali::Path result;
37921
37922   {
37923     try {
37924       result = Dali::Path::New();
37925     } catch (std::out_of_range& e) {
37926       {
37927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37928       };
37929     } catch (std::exception& e) {
37930       {
37931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37932       };
37933     } catch (...) {
37934       {
37935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37936       };
37937     }
37938   }
37939   jresult = new Dali::Path((const Dali::Path &)result);
37940   return jresult;
37941 }
37942
37943
37944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
37945   void * jresult ;
37946   Dali::BaseHandle arg1 ;
37947   Dali::BaseHandle *argp1 ;
37948   Dali::Path result;
37949
37950   argp1 = (Dali::BaseHandle *)jarg1;
37951   if (!argp1) {
37952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37953     return 0;
37954   }
37955   arg1 = *argp1;
37956   {
37957     try {
37958       result = Dali::Path::DownCast(arg1);
37959     } catch (std::out_of_range& e) {
37960       {
37961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37962       };
37963     } catch (std::exception& e) {
37964       {
37965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37966       };
37967     } catch (...) {
37968       {
37969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37970       };
37971     }
37972   }
37973   jresult = new Dali::Path((const Dali::Path &)result);
37974   return jresult;
37975 }
37976
37977
37978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
37979   void * jresult ;
37980   Dali::Path *result = 0 ;
37981
37982   {
37983     try {
37984       result = (Dali::Path *)new Dali::Path();
37985     } catch (std::out_of_range& e) {
37986       {
37987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37988       };
37989     } catch (std::exception& e) {
37990       {
37991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37992       };
37993     } catch (...) {
37994       {
37995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37996       };
37997     }
37998   }
37999   jresult = (void *)result;
38000   return jresult;
38001 }
38002
38003
38004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
38005   Dali::Path *arg1 = (Dali::Path *) 0 ;
38006
38007   arg1 = (Dali::Path *)jarg1;
38008   {
38009     try {
38010       delete arg1;
38011     } catch (std::out_of_range& e) {
38012       {
38013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38014       };
38015     } catch (std::exception& e) {
38016       {
38017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38018       };
38019     } catch (...) {
38020       {
38021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38022       };
38023     }
38024   }
38025 }
38026
38027
38028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
38029   void * jresult ;
38030   Dali::Path *arg1 = 0 ;
38031   Dali::Path *result = 0 ;
38032
38033   arg1 = (Dali::Path *)jarg1;
38034   if (!arg1) {
38035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
38036     return 0;
38037   }
38038   {
38039     try {
38040       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
38041     } catch (std::out_of_range& e) {
38042       {
38043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38044       };
38045     } catch (std::exception& e) {
38046       {
38047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38048       };
38049     } catch (...) {
38050       {
38051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38052       };
38053     }
38054   }
38055   jresult = (void *)result;
38056   return jresult;
38057 }
38058
38059
38060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
38061   void * jresult ;
38062   Dali::Path *arg1 = (Dali::Path *) 0 ;
38063   Dali::Path *arg2 = 0 ;
38064   Dali::Path *result = 0 ;
38065
38066   arg1 = (Dali::Path *)jarg1;
38067   arg2 = (Dali::Path *)jarg2;
38068   if (!arg2) {
38069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
38070     return 0;
38071   }
38072   {
38073     try {
38074       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
38075     } catch (std::out_of_range& e) {
38076       {
38077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38078       };
38079     } catch (std::exception& e) {
38080       {
38081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38082       };
38083     } catch (...) {
38084       {
38085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38086       };
38087     }
38088   }
38089   jresult = (void *)result;
38090   return jresult;
38091 }
38092
38093
38094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
38095   Dali::Path *arg1 = (Dali::Path *) 0 ;
38096   Dali::Vector3 *arg2 = 0 ;
38097
38098   arg1 = (Dali::Path *)jarg1;
38099   arg2 = (Dali::Vector3 *)jarg2;
38100   if (!arg2) {
38101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38102     return ;
38103   }
38104   {
38105     try {
38106       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
38107     } catch (std::out_of_range& e) {
38108       {
38109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38110       };
38111     } catch (std::exception& e) {
38112       {
38113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38114       };
38115     } catch (...) {
38116       {
38117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38118       };
38119     }
38120   }
38121 }
38122
38123
38124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
38125   Dali::Path *arg1 = (Dali::Path *) 0 ;
38126   Dali::Vector3 *arg2 = 0 ;
38127
38128   arg1 = (Dali::Path *)jarg1;
38129   arg2 = (Dali::Vector3 *)jarg2;
38130   if (!arg2) {
38131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38132     return ;
38133   }
38134   {
38135     try {
38136       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
38137     } catch (std::out_of_range& e) {
38138       {
38139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38140       };
38141     } catch (std::exception& e) {
38142       {
38143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38144       };
38145     } catch (...) {
38146       {
38147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38148       };
38149     }
38150   }
38151 }
38152
38153
38154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
38155   Dali::Path *arg1 = (Dali::Path *) 0 ;
38156   float arg2 ;
38157
38158   arg1 = (Dali::Path *)jarg1;
38159   arg2 = (float)jarg2;
38160   {
38161     try {
38162       (arg1)->GenerateControlPoints(arg2);
38163     } catch (std::out_of_range& e) {
38164       {
38165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38166       };
38167     } catch (std::exception& e) {
38168       {
38169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38170       };
38171     } catch (...) {
38172       {
38173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38174       };
38175     }
38176   }
38177 }
38178
38179
38180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
38181   Dali::Path *arg1 = (Dali::Path *) 0 ;
38182   float arg2 ;
38183   Dali::Vector3 *arg3 = 0 ;
38184   Dali::Vector3 *arg4 = 0 ;
38185
38186   arg1 = (Dali::Path *)jarg1;
38187   arg2 = (float)jarg2;
38188   arg3 = (Dali::Vector3 *)jarg3;
38189   if (!arg3) {
38190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38191     return ;
38192   }
38193   arg4 = (Dali::Vector3 *)jarg4;
38194   if (!arg4) {
38195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38196     return ;
38197   }
38198   {
38199     try {
38200       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
38201     } catch (std::out_of_range& e) {
38202       {
38203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38204       };
38205     } catch (std::exception& e) {
38206       {
38207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38208       };
38209     } catch (...) {
38210       {
38211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38212       };
38213     }
38214   }
38215 }
38216
38217
38218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
38219   void * jresult ;
38220   Dali::Path *arg1 = (Dali::Path *) 0 ;
38221   size_t arg2 ;
38222   Dali::Vector3 *result = 0 ;
38223
38224   arg1 = (Dali::Path *)jarg1;
38225   arg2 = (size_t)jarg2;
38226   {
38227     try {
38228       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
38229     } catch (std::out_of_range& e) {
38230       {
38231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38232       };
38233     } catch (std::exception& e) {
38234       {
38235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38236       };
38237     } catch (...) {
38238       {
38239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38240       };
38241     }
38242   }
38243   jresult = (void *)result;
38244   return jresult;
38245 }
38246
38247
38248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
38249   void * jresult ;
38250   Dali::Path *arg1 = (Dali::Path *) 0 ;
38251   size_t arg2 ;
38252   Dali::Vector3 *result = 0 ;
38253
38254   arg1 = (Dali::Path *)jarg1;
38255   arg2 = (size_t)jarg2;
38256   {
38257     try {
38258       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
38259     } catch (std::out_of_range& e) {
38260       {
38261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38262       };
38263     } catch (std::exception& e) {
38264       {
38265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38266       };
38267     } catch (...) {
38268       {
38269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38270       };
38271     }
38272   }
38273   jresult = (void *)result;
38274   return jresult;
38275 }
38276
38277
38278 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
38279   unsigned long jresult ;
38280   Dali::Path *arg1 = (Dali::Path *) 0 ;
38281   size_t result;
38282
38283   arg1 = (Dali::Path *)jarg1;
38284   {
38285     try {
38286       result = ((Dali::Path const *)arg1)->GetPointCount();
38287     } catch (std::out_of_range& e) {
38288       {
38289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38290       };
38291     } catch (std::exception& e) {
38292       {
38293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38294       };
38295     } catch (...) {
38296       {
38297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38298       };
38299     }
38300   }
38301   jresult = (unsigned long)result;
38302   return jresult;
38303 }
38304
38305
38306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
38307   void * jresult ;
38308   float arg1 ;
38309   Dali::TimePeriod *result = 0 ;
38310
38311   arg1 = (float)jarg1;
38312   {
38313     try {
38314       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
38315     } catch (std::out_of_range& e) {
38316       {
38317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38318       };
38319     } catch (std::exception& e) {
38320       {
38321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38322       };
38323     } catch (...) {
38324       {
38325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38326       };
38327     }
38328   }
38329   jresult = (void *)result;
38330   return jresult;
38331 }
38332
38333
38334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
38335   void * jresult ;
38336   float arg1 ;
38337   float arg2 ;
38338   Dali::TimePeriod *result = 0 ;
38339
38340   arg1 = (float)jarg1;
38341   arg2 = (float)jarg2;
38342   {
38343     try {
38344       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
38345     } catch (std::out_of_range& e) {
38346       {
38347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38348       };
38349     } catch (std::exception& e) {
38350       {
38351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38352       };
38353     } catch (...) {
38354       {
38355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38356       };
38357     }
38358   }
38359   jresult = (void *)result;
38360   return jresult;
38361 }
38362
38363
38364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
38365   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38366
38367   arg1 = (Dali::TimePeriod *)jarg1;
38368   {
38369     try {
38370       delete arg1;
38371     } catch (std::out_of_range& e) {
38372       {
38373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38374       };
38375     } catch (std::exception& e) {
38376       {
38377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38378       };
38379     } catch (...) {
38380       {
38381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38382       };
38383     }
38384   }
38385 }
38386
38387
38388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
38389   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38390   float arg2 ;
38391
38392   arg1 = (Dali::TimePeriod *)jarg1;
38393   arg2 = (float)jarg2;
38394   if (arg1) (arg1)->delaySeconds = arg2;
38395 }
38396
38397
38398 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
38399   float jresult ;
38400   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38401   float result;
38402
38403   arg1 = (Dali::TimePeriod *)jarg1;
38404   result = (float) ((arg1)->delaySeconds);
38405   jresult = result;
38406   return jresult;
38407 }
38408
38409
38410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
38411   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38412   float arg2 ;
38413
38414   arg1 = (Dali::TimePeriod *)jarg1;
38415   arg2 = (float)jarg2;
38416   if (arg1) (arg1)->durationSeconds = arg2;
38417 }
38418
38419
38420 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
38421   float jresult ;
38422   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38423   float result;
38424
38425   arg1 = (Dali::TimePeriod *)jarg1;
38426   result = (float) ((arg1)->durationSeconds);
38427   jresult = result;
38428   return jresult;
38429 }
38430
38431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
38432   int jresult ;
38433   int result;
38434
38435   result = (int)Dali::LinearConstrainer::Property::VALUE;
38436   jresult = (int)result;
38437   return jresult;
38438 }
38439
38440
38441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
38442   int jresult ;
38443   int result;
38444
38445   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
38446   jresult = (int)result;
38447   return jresult;
38448 }
38449
38450
38451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
38452   void * jresult ;
38453   Dali::LinearConstrainer::Property *result = 0 ;
38454
38455   {
38456     try {
38457       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
38458     } catch (std::out_of_range& e) {
38459       {
38460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38461       };
38462     } catch (std::exception& e) {
38463       {
38464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38465       };
38466     } catch (...) {
38467       {
38468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38469       };
38470     }
38471   }
38472   jresult = (void *)result;
38473   return jresult;
38474 }
38475
38476
38477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
38478   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
38479
38480   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
38481   {
38482     try {
38483       delete arg1;
38484     } catch (std::out_of_range& e) {
38485       {
38486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38487       };
38488     } catch (std::exception& e) {
38489       {
38490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38491       };
38492     } catch (...) {
38493       {
38494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38495       };
38496     }
38497   }
38498 }
38499
38500
38501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
38502   void * jresult ;
38503   Dali::LinearConstrainer result;
38504
38505   {
38506     try {
38507       result = Dali::LinearConstrainer::New();
38508     } catch (std::out_of_range& e) {
38509       {
38510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38511       };
38512     } catch (std::exception& e) {
38513       {
38514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38515       };
38516     } catch (...) {
38517       {
38518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38519       };
38520     }
38521   }
38522   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
38523   return jresult;
38524 }
38525
38526
38527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
38528   void * jresult ;
38529   Dali::BaseHandle arg1 ;
38530   Dali::BaseHandle *argp1 ;
38531   Dali::LinearConstrainer result;
38532
38533   argp1 = (Dali::BaseHandle *)jarg1;
38534   if (!argp1) {
38535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38536     return 0;
38537   }
38538   arg1 = *argp1;
38539   {
38540     try {
38541       result = Dali::LinearConstrainer::DownCast(arg1);
38542     } catch (std::out_of_range& e) {
38543       {
38544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38545       };
38546     } catch (std::exception& e) {
38547       {
38548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38549       };
38550     } catch (...) {
38551       {
38552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38553       };
38554     }
38555   }
38556   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
38557   return jresult;
38558 }
38559
38560
38561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
38562   void * jresult ;
38563   Dali::LinearConstrainer *result = 0 ;
38564
38565   {
38566     try {
38567       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
38568     } catch (std::out_of_range& e) {
38569       {
38570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38571       };
38572     } catch (std::exception& e) {
38573       {
38574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38575       };
38576     } catch (...) {
38577       {
38578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38579       };
38580     }
38581   }
38582   jresult = (void *)result;
38583   return jresult;
38584 }
38585
38586
38587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
38588   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
38589
38590   arg1 = (Dali::LinearConstrainer *)jarg1;
38591   {
38592     try {
38593       delete arg1;
38594     } catch (std::out_of_range& e) {
38595       {
38596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38597       };
38598     } catch (std::exception& e) {
38599       {
38600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38601       };
38602     } catch (...) {
38603       {
38604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38605       };
38606     }
38607   }
38608 }
38609
38610
38611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
38612   void * jresult ;
38613   Dali::LinearConstrainer *arg1 = 0 ;
38614   Dali::LinearConstrainer *result = 0 ;
38615
38616   arg1 = (Dali::LinearConstrainer *)jarg1;
38617   if (!arg1) {
38618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
38619     return 0;
38620   }
38621   {
38622     try {
38623       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
38624     } catch (std::out_of_range& e) {
38625       {
38626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38627       };
38628     } catch (std::exception& e) {
38629       {
38630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38631       };
38632     } catch (...) {
38633       {
38634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38635       };
38636     }
38637   }
38638   jresult = (void *)result;
38639   return jresult;
38640 }
38641
38642
38643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
38644   void * jresult ;
38645   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
38646   Dali::LinearConstrainer *arg2 = 0 ;
38647   Dali::LinearConstrainer *result = 0 ;
38648
38649   arg1 = (Dali::LinearConstrainer *)jarg1;
38650   arg2 = (Dali::LinearConstrainer *)jarg2;
38651   if (!arg2) {
38652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
38653     return 0;
38654   }
38655   {
38656     try {
38657       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
38658     } catch (std::out_of_range& e) {
38659       {
38660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38661       };
38662     } catch (std::exception& e) {
38663       {
38664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38665       };
38666     } catch (...) {
38667       {
38668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38669       };
38670     }
38671   }
38672   jresult = (void *)result;
38673   return jresult;
38674 }
38675
38676
38677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
38678   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
38679   SwigValueWrapper< Dali::Property > arg2 ;
38680   SwigValueWrapper< Dali::Property > arg3 ;
38681   Dali::Vector2 *arg4 = 0 ;
38682   Dali::Vector2 *arg5 = 0 ;
38683   Dali::Property *argp2 ;
38684   Dali::Property *argp3 ;
38685
38686   arg1 = (Dali::LinearConstrainer *)jarg1;
38687   argp2 = (Dali::Property *)jarg2;
38688   if (!argp2) {
38689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
38690     return ;
38691   }
38692   arg2 = *argp2;
38693   argp3 = (Dali::Property *)jarg3;
38694   if (!argp3) {
38695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
38696     return ;
38697   }
38698   arg3 = *argp3;
38699   arg4 = (Dali::Vector2 *)jarg4;
38700   if (!arg4) {
38701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38702     return ;
38703   }
38704   arg5 = (Dali::Vector2 *)jarg5;
38705   if (!arg5) {
38706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38707     return ;
38708   }
38709   {
38710     try {
38711       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
38712     } catch (std::out_of_range& e) {
38713       {
38714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38715       };
38716     } catch (std::exception& e) {
38717       {
38718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38719       };
38720     } catch (...) {
38721       {
38722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38723       };
38724     }
38725   }
38726 }
38727
38728
38729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
38730   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
38731   SwigValueWrapper< Dali::Property > arg2 ;
38732   SwigValueWrapper< Dali::Property > arg3 ;
38733   Dali::Vector2 *arg4 = 0 ;
38734   Dali::Property *argp2 ;
38735   Dali::Property *argp3 ;
38736
38737   arg1 = (Dali::LinearConstrainer *)jarg1;
38738   argp2 = (Dali::Property *)jarg2;
38739   if (!argp2) {
38740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
38741     return ;
38742   }
38743   arg2 = *argp2;
38744   argp3 = (Dali::Property *)jarg3;
38745   if (!argp3) {
38746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
38747     return ;
38748   }
38749   arg3 = *argp3;
38750   arg4 = (Dali::Vector2 *)jarg4;
38751   if (!arg4) {
38752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38753     return ;
38754   }
38755   {
38756     try {
38757       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
38758     } catch (std::out_of_range& e) {
38759       {
38760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38761       };
38762     } catch (std::exception& e) {
38763       {
38764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38765       };
38766     } catch (...) {
38767       {
38768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38769       };
38770     }
38771   }
38772 }
38773
38774
38775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
38776   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
38777   Dali::Handle *arg2 = 0 ;
38778
38779   arg1 = (Dali::LinearConstrainer *)jarg1;
38780   arg2 = (Dali::Handle *)jarg2;
38781   if (!arg2) {
38782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
38783     return ;
38784   }
38785   {
38786     try {
38787       (arg1)->Remove(*arg2);
38788     } catch (std::out_of_range& e) {
38789       {
38790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38791       };
38792     } catch (std::exception& e) {
38793       {
38794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38795       };
38796     } catch (...) {
38797       {
38798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38799       };
38800     }
38801   }
38802 }
38803
38804
38805 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
38806   int jresult ;
38807   int result;
38808
38809   result = (int)Dali::PathConstrainer::Property::FORWARD;
38810   jresult = (int)result;
38811   return jresult;
38812 }
38813
38814
38815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
38816   int jresult ;
38817   int result;
38818
38819   result = (int)Dali::PathConstrainer::Property::POINTS;
38820   jresult = (int)result;
38821   return jresult;
38822 }
38823
38824
38825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
38826   int jresult ;
38827   int result;
38828
38829   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
38830   jresult = (int)result;
38831   return jresult;
38832 }
38833
38834
38835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
38836   void * jresult ;
38837   Dali::PathConstrainer::Property *result = 0 ;
38838
38839   {
38840     try {
38841       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
38842     } catch (std::out_of_range& e) {
38843       {
38844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38845       };
38846     } catch (std::exception& e) {
38847       {
38848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38849       };
38850     } catch (...) {
38851       {
38852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38853       };
38854     }
38855   }
38856   jresult = (void *)result;
38857   return jresult;
38858 }
38859
38860
38861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
38862   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
38863
38864   arg1 = (Dali::PathConstrainer::Property *)jarg1;
38865   {
38866     try {
38867       delete arg1;
38868     } catch (std::out_of_range& e) {
38869       {
38870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38871       };
38872     } catch (std::exception& e) {
38873       {
38874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38875       };
38876     } catch (...) {
38877       {
38878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38879       };
38880     }
38881   }
38882 }
38883
38884
38885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
38886   void * jresult ;
38887   Dali::PathConstrainer result;
38888
38889   {
38890     try {
38891       result = Dali::PathConstrainer::New();
38892     } catch (std::out_of_range& e) {
38893       {
38894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38895       };
38896     } catch (std::exception& e) {
38897       {
38898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38899       };
38900     } catch (...) {
38901       {
38902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38903       };
38904     }
38905   }
38906   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
38907   return jresult;
38908 }
38909
38910
38911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
38912   void * jresult ;
38913   Dali::BaseHandle arg1 ;
38914   Dali::BaseHandle *argp1 ;
38915   Dali::PathConstrainer result;
38916
38917   argp1 = (Dali::BaseHandle *)jarg1;
38918   if (!argp1) {
38919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38920     return 0;
38921   }
38922   arg1 = *argp1;
38923   {
38924     try {
38925       result = Dali::PathConstrainer::DownCast(arg1);
38926     } catch (std::out_of_range& e) {
38927       {
38928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38929       };
38930     } catch (std::exception& e) {
38931       {
38932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38933       };
38934     } catch (...) {
38935       {
38936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38937       };
38938     }
38939   }
38940   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
38941   return jresult;
38942 }
38943
38944
38945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
38946   void * jresult ;
38947   Dali::PathConstrainer *result = 0 ;
38948
38949   {
38950     try {
38951       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
38952     } catch (std::out_of_range& e) {
38953       {
38954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38955       };
38956     } catch (std::exception& e) {
38957       {
38958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38959       };
38960     } catch (...) {
38961       {
38962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38963       };
38964     }
38965   }
38966   jresult = (void *)result;
38967   return jresult;
38968 }
38969
38970
38971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
38972   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
38973
38974   arg1 = (Dali::PathConstrainer *)jarg1;
38975   {
38976     try {
38977       delete arg1;
38978     } catch (std::out_of_range& e) {
38979       {
38980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38981       };
38982     } catch (std::exception& e) {
38983       {
38984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38985       };
38986     } catch (...) {
38987       {
38988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38989       };
38990     }
38991   }
38992 }
38993
38994
38995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
38996   void * jresult ;
38997   Dali::PathConstrainer *arg1 = 0 ;
38998   Dali::PathConstrainer *result = 0 ;
38999
39000   arg1 = (Dali::PathConstrainer *)jarg1;
39001   if (!arg1) {
39002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
39003     return 0;
39004   }
39005   {
39006     try {
39007       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
39008     } catch (std::out_of_range& e) {
39009       {
39010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39011       };
39012     } catch (std::exception& e) {
39013       {
39014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39015       };
39016     } catch (...) {
39017       {
39018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39019       };
39020     }
39021   }
39022   jresult = (void *)result;
39023   return jresult;
39024 }
39025
39026
39027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
39028   void * jresult ;
39029   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
39030   Dali::PathConstrainer *arg2 = 0 ;
39031   Dali::PathConstrainer *result = 0 ;
39032
39033   arg1 = (Dali::PathConstrainer *)jarg1;
39034   arg2 = (Dali::PathConstrainer *)jarg2;
39035   if (!arg2) {
39036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
39037     return 0;
39038   }
39039   {
39040     try {
39041       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
39042     } catch (std::out_of_range& e) {
39043       {
39044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39045       };
39046     } catch (std::exception& e) {
39047       {
39048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39049       };
39050     } catch (...) {
39051       {
39052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39053       };
39054     }
39055   }
39056   jresult = (void *)result;
39057   return jresult;
39058 }
39059
39060
39061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39062   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
39063   SwigValueWrapper< Dali::Property > arg2 ;
39064   SwigValueWrapper< Dali::Property > arg3 ;
39065   Dali::Vector2 *arg4 = 0 ;
39066   Dali::Vector2 *arg5 = 0 ;
39067   Dali::Property *argp2 ;
39068   Dali::Property *argp3 ;
39069
39070   arg1 = (Dali::PathConstrainer *)jarg1;
39071   argp2 = (Dali::Property *)jarg2;
39072   if (!argp2) {
39073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39074     return ;
39075   }
39076   arg2 = *argp2;
39077   argp3 = (Dali::Property *)jarg3;
39078   if (!argp3) {
39079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39080     return ;
39081   }
39082   arg3 = *argp3;
39083   arg4 = (Dali::Vector2 *)jarg4;
39084   if (!arg4) {
39085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39086     return ;
39087   }
39088   arg5 = (Dali::Vector2 *)jarg5;
39089   if (!arg5) {
39090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39091     return ;
39092   }
39093   {
39094     try {
39095       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
39096     } catch (std::out_of_range& e) {
39097       {
39098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39099       };
39100     } catch (std::exception& e) {
39101       {
39102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39103       };
39104     } catch (...) {
39105       {
39106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39107       };
39108     }
39109   }
39110 }
39111
39112
39113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39114   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
39115   SwigValueWrapper< Dali::Property > arg2 ;
39116   SwigValueWrapper< Dali::Property > arg3 ;
39117   Dali::Vector2 *arg4 = 0 ;
39118   Dali::Property *argp2 ;
39119   Dali::Property *argp3 ;
39120
39121   arg1 = (Dali::PathConstrainer *)jarg1;
39122   argp2 = (Dali::Property *)jarg2;
39123   if (!argp2) {
39124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39125     return ;
39126   }
39127   arg2 = *argp2;
39128   argp3 = (Dali::Property *)jarg3;
39129   if (!argp3) {
39130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39131     return ;
39132   }
39133   arg3 = *argp3;
39134   arg4 = (Dali::Vector2 *)jarg4;
39135   if (!arg4) {
39136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39137     return ;
39138   }
39139   {
39140     try {
39141       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
39142     } catch (std::out_of_range& e) {
39143       {
39144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39145       };
39146     } catch (std::exception& e) {
39147       {
39148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39149       };
39150     } catch (...) {
39151       {
39152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39153       };
39154     }
39155   }
39156 }
39157
39158
39159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
39160   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
39161   Dali::Handle *arg2 = 0 ;
39162
39163   arg1 = (Dali::PathConstrainer *)jarg1;
39164   arg2 = (Dali::Handle *)jarg2;
39165   if (!arg2) {
39166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
39167     return ;
39168   }
39169   {
39170     try {
39171       (arg1)->Remove(*arg2);
39172     } catch (std::out_of_range& e) {
39173       {
39174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39175       };
39176     } catch (std::exception& e) {
39177       {
39178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39179       };
39180     } catch (...) {
39181       {
39182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39183       };
39184     }
39185   }
39186 }
39187
39188
39189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
39190   int jresult ;
39191   Dali::FittingMode::Type result;
39192
39193   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
39194   jresult = (int)result;
39195   return jresult;
39196 }
39197
39198
39199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
39200   int jresult ;
39201   Dali::SamplingMode::Type result;
39202
39203   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
39204   jresult = (int)result;
39205   return jresult;
39206 }
39207
39208
39209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
39210   void * jresult ;
39211   Dali::BufferImage *result = 0 ;
39212
39213   {
39214     try {
39215       result = (Dali::BufferImage *)new Dali::BufferImage();
39216     } catch (std::out_of_range& e) {
39217       {
39218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39219       };
39220     } catch (std::exception& e) {
39221       {
39222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39223       };
39224     } catch (...) {
39225       {
39226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39227       };
39228     }
39229   }
39230   jresult = (void *)result;
39231   return jresult;
39232 }
39233
39234
39235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
39236   void * jresult ;
39237   unsigned int arg1 ;
39238   unsigned int arg2 ;
39239   Dali::Pixel::Format arg3 ;
39240   Dali::BufferImage result;
39241
39242   arg1 = (unsigned int)jarg1;
39243   arg2 = (unsigned int)jarg2;
39244   arg3 = (Dali::Pixel::Format)jarg3;
39245   {
39246     try {
39247       result = Dali::BufferImage::New(arg1,arg2,arg3);
39248     } catch (std::out_of_range& e) {
39249       {
39250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39251       };
39252     } catch (std::exception& e) {
39253       {
39254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39255       };
39256     } catch (...) {
39257       {
39258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39259       };
39260     }
39261   }
39262   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39263   return jresult;
39264 }
39265
39266
39267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
39268   void * jresult ;
39269   unsigned int arg1 ;
39270   unsigned int arg2 ;
39271   Dali::BufferImage result;
39272
39273   arg1 = (unsigned int)jarg1;
39274   arg2 = (unsigned int)jarg2;
39275   {
39276     try {
39277       result = Dali::BufferImage::New(arg1,arg2);
39278     } catch (std::out_of_range& e) {
39279       {
39280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39281       };
39282     } catch (std::exception& e) {
39283       {
39284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39285       };
39286     } catch (...) {
39287       {
39288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39289       };
39290     }
39291   }
39292   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39293   return jresult;
39294 }
39295
39296
39297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
39298   void * jresult ;
39299   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
39300   unsigned int arg2 ;
39301   unsigned int arg3 ;
39302   Dali::Pixel::Format arg4 ;
39303   unsigned int arg5 ;
39304   Dali::BufferImage result;
39305
39306   arg1 = jarg1;
39307   arg2 = (unsigned int)jarg2;
39308   arg3 = (unsigned int)jarg3;
39309   arg4 = (Dali::Pixel::Format)jarg4;
39310   arg5 = (unsigned int)jarg5;
39311   {
39312     try {
39313       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
39314     } catch (std::out_of_range& e) {
39315       {
39316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39317       };
39318     } catch (std::exception& e) {
39319       {
39320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39321       };
39322     } catch (...) {
39323       {
39324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39325       };
39326     }
39327   }
39328   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39329
39330
39331   return jresult;
39332 }
39333
39334
39335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
39336   void * jresult ;
39337   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
39338   unsigned int arg2 ;
39339   unsigned int arg3 ;
39340   Dali::Pixel::Format arg4 ;
39341   Dali::BufferImage result;
39342
39343   arg1 = jarg1;
39344   arg2 = (unsigned int)jarg2;
39345   arg3 = (unsigned int)jarg3;
39346   arg4 = (Dali::Pixel::Format)jarg4;
39347   {
39348     try {
39349       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
39350     } catch (std::out_of_range& e) {
39351       {
39352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39353       };
39354     } catch (std::exception& e) {
39355       {
39356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39357       };
39358     } catch (...) {
39359       {
39360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39361       };
39362     }
39363   }
39364   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39365
39366
39367   return jresult;
39368 }
39369
39370
39371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
39372   void * jresult ;
39373   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
39374   unsigned int arg2 ;
39375   unsigned int arg3 ;
39376   Dali::BufferImage result;
39377
39378   arg1 = jarg1;
39379   arg2 = (unsigned int)jarg2;
39380   arg3 = (unsigned int)jarg3;
39381   {
39382     try {
39383       result = Dali::BufferImage::New(arg1,arg2,arg3);
39384     } catch (std::out_of_range& e) {
39385       {
39386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39387       };
39388     } catch (std::exception& e) {
39389       {
39390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39391       };
39392     } catch (...) {
39393       {
39394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39395       };
39396     }
39397   }
39398   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39399
39400
39401   return jresult;
39402 }
39403
39404
39405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
39406   void * jresult ;
39407   Dali::BaseHandle arg1 ;
39408   Dali::BaseHandle *argp1 ;
39409   Dali::BufferImage result;
39410
39411   argp1 = (Dali::BaseHandle *)jarg1;
39412   if (!argp1) {
39413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39414     return 0;
39415   }
39416   arg1 = *argp1;
39417   {
39418     try {
39419       result = Dali::BufferImage::DownCast(arg1);
39420     } catch (std::out_of_range& e) {
39421       {
39422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39423       };
39424     } catch (std::exception& e) {
39425       {
39426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39427       };
39428     } catch (...) {
39429       {
39430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39431       };
39432     }
39433   }
39434   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39435   return jresult;
39436 }
39437
39438
39439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
39440   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39441
39442   arg1 = (Dali::BufferImage *)jarg1;
39443   {
39444     try {
39445       delete arg1;
39446     } catch (std::out_of_range& e) {
39447       {
39448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39449       };
39450     } catch (std::exception& e) {
39451       {
39452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39453       };
39454     } catch (...) {
39455       {
39456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39457       };
39458     }
39459   }
39460 }
39461
39462
39463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
39464   void * jresult ;
39465   Dali::BufferImage *arg1 = 0 ;
39466   Dali::BufferImage *result = 0 ;
39467
39468   arg1 = (Dali::BufferImage *)jarg1;
39469   if (!arg1) {
39470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
39471     return 0;
39472   }
39473   {
39474     try {
39475       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
39476     } catch (std::out_of_range& e) {
39477       {
39478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39479       };
39480     } catch (std::exception& e) {
39481       {
39482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39483       };
39484     } catch (...) {
39485       {
39486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39487       };
39488     }
39489   }
39490   jresult = (void *)result;
39491   return jresult;
39492 }
39493
39494
39495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
39496   void * jresult ;
39497   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39498   Dali::BufferImage *arg2 = 0 ;
39499   Dali::BufferImage *result = 0 ;
39500
39501   arg1 = (Dali::BufferImage *)jarg1;
39502   arg2 = (Dali::BufferImage *)jarg2;
39503   if (!arg2) {
39504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
39505     return 0;
39506   }
39507   {
39508     try {
39509       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
39510     } catch (std::out_of_range& e) {
39511       {
39512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39513       };
39514     } catch (std::exception& e) {
39515       {
39516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39517       };
39518     } catch (...) {
39519       {
39520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39521       };
39522     }
39523   }
39524   jresult = (void *)result;
39525   return jresult;
39526 }
39527
39528
39529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
39530   void * jresult ;
39531   Dali::BufferImage result;
39532
39533   {
39534     try {
39535       result = Dali::BufferImage::WHITE();
39536     } catch (std::out_of_range& e) {
39537       {
39538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39539       };
39540     } catch (std::exception& e) {
39541       {
39542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39543       };
39544     } catch (...) {
39545       {
39546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39547       };
39548     }
39549   }
39550   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39551   return jresult;
39552 }
39553
39554
39555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
39556   void * jresult ;
39557   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39558   Dali::PixelBuffer *result = 0 ;
39559
39560   arg1 = (Dali::BufferImage *)jarg1;
39561   {
39562     try {
39563       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
39564     } catch (std::out_of_range& e) {
39565       {
39566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39567       };
39568     } catch (std::exception& e) {
39569       {
39570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39571       };
39572     } catch (...) {
39573       {
39574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39575       };
39576     }
39577   }
39578   jresult = (void *)result;
39579   return jresult;
39580 }
39581
39582
39583 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
39584   unsigned int jresult ;
39585   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39586   unsigned int result;
39587
39588   arg1 = (Dali::BufferImage *)jarg1;
39589   {
39590     try {
39591       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
39592     } catch (std::out_of_range& e) {
39593       {
39594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39595       };
39596     } catch (std::exception& e) {
39597       {
39598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39599       };
39600     } catch (...) {
39601       {
39602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39603       };
39604     }
39605   }
39606   jresult = result;
39607   return jresult;
39608 }
39609
39610
39611 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
39612   unsigned int jresult ;
39613   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39614   unsigned int result;
39615
39616   arg1 = (Dali::BufferImage *)jarg1;
39617   {
39618     try {
39619       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
39620     } catch (std::out_of_range& e) {
39621       {
39622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39623       };
39624     } catch (std::exception& e) {
39625       {
39626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39627       };
39628     } catch (...) {
39629       {
39630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39631       };
39632     }
39633   }
39634   jresult = result;
39635   return jresult;
39636 }
39637
39638
39639 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
39640   int jresult ;
39641   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39642   Dali::Pixel::Format result;
39643
39644   arg1 = (Dali::BufferImage *)jarg1;
39645   {
39646     try {
39647       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
39648     } catch (std::out_of_range& e) {
39649       {
39650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39651       };
39652     } catch (std::exception& e) {
39653       {
39654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39655       };
39656     } catch (...) {
39657       {
39658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39659       };
39660     }
39661   }
39662   jresult = (int)result;
39663   return jresult;
39664 }
39665
39666
39667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
39668   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39669
39670   arg1 = (Dali::BufferImage *)jarg1;
39671   {
39672     try {
39673       (arg1)->Update();
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_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
39692   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39693   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
39694   Dali::RectArea *argp2 ;
39695
39696   arg1 = (Dali::BufferImage *)jarg1;
39697   argp2 = (Dali::RectArea *)jarg2;
39698   if (!argp2) {
39699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
39700     return ;
39701   }
39702   arg2 = *argp2;
39703   {
39704     try {
39705       (arg1)->Update(arg2);
39706     } catch (std::out_of_range& e) {
39707       {
39708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39709       };
39710     } catch (std::exception& e) {
39711       {
39712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39713       };
39714     } catch (...) {
39715       {
39716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39717       };
39718     }
39719   }
39720 }
39721
39722
39723 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
39724   unsigned int jresult ;
39725   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39726   bool result;
39727
39728   arg1 = (Dali::BufferImage *)jarg1;
39729   {
39730     try {
39731       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
39732     } catch (std::out_of_range& e) {
39733       {
39734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39735       };
39736     } catch (std::exception& e) {
39737       {
39738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39739       };
39740     } catch (...) {
39741       {
39742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39743       };
39744     }
39745   }
39746   jresult = result;
39747   return jresult;
39748 }
39749
39750
39751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
39752   void * jresult ;
39753   Dali::EncodedBufferImage *result = 0 ;
39754
39755   {
39756     try {
39757       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
39758     } catch (std::out_of_range& e) {
39759       {
39760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39761       };
39762     } catch (std::exception& e) {
39763       {
39764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39765       };
39766     } catch (...) {
39767       {
39768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39769       };
39770     }
39771   }
39772   jresult = (void *)result;
39773   return jresult;
39774 }
39775
39776
39777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
39778   void * jresult ;
39779   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
39780   std::size_t arg2 ;
39781   Dali::EncodedBufferImage result;
39782
39783   arg1 = (uint8_t *)jarg1;
39784   arg2 = (std::size_t)jarg2;
39785   {
39786     try {
39787       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
39788     } catch (std::out_of_range& e) {
39789       {
39790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39791       };
39792     } catch (std::exception& e) {
39793       {
39794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39795       };
39796     } catch (...) {
39797       {
39798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39799       };
39800     }
39801   }
39802   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
39803   return jresult;
39804 }
39805
39806
39807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
39808   void * jresult ;
39809   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
39810   std::size_t arg2 ;
39811   Dali::ImageDimensions arg3 ;
39812   Dali::FittingMode::Type arg4 ;
39813   Dali::SamplingMode::Type arg5 ;
39814   bool arg6 ;
39815   Dali::ImageDimensions *argp3 ;
39816   Dali::EncodedBufferImage result;
39817
39818   arg1 = (uint8_t *)jarg1;
39819   arg2 = (std::size_t)jarg2;
39820   argp3 = (Dali::ImageDimensions *)jarg3;
39821   if (!argp3) {
39822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
39823     return 0;
39824   }
39825   arg3 = *argp3;
39826   arg4 = (Dali::FittingMode::Type)jarg4;
39827   arg5 = (Dali::SamplingMode::Type)jarg5;
39828   arg6 = jarg6 ? true : false;
39829   {
39830     try {
39831       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
39832     } catch (std::out_of_range& e) {
39833       {
39834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39835       };
39836     } catch (std::exception& e) {
39837       {
39838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39839       };
39840     } catch (...) {
39841       {
39842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39843       };
39844     }
39845   }
39846   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
39847   return jresult;
39848 }
39849
39850
39851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
39852   void * jresult ;
39853   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
39854   std::size_t arg2 ;
39855   Dali::ImageDimensions arg3 ;
39856   Dali::FittingMode::Type arg4 ;
39857   Dali::SamplingMode::Type arg5 ;
39858   Dali::ImageDimensions *argp3 ;
39859   Dali::EncodedBufferImage result;
39860
39861   arg1 = (uint8_t *)jarg1;
39862   arg2 = (std::size_t)jarg2;
39863   argp3 = (Dali::ImageDimensions *)jarg3;
39864   if (!argp3) {
39865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
39866     return 0;
39867   }
39868   arg3 = *argp3;
39869   arg4 = (Dali::FittingMode::Type)jarg4;
39870   arg5 = (Dali::SamplingMode::Type)jarg5;
39871   {
39872     try {
39873       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
39874     } catch (std::out_of_range& e) {
39875       {
39876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39877       };
39878     } catch (std::exception& e) {
39879       {
39880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39881       };
39882     } catch (...) {
39883       {
39884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39885       };
39886     }
39887   }
39888   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
39889   return jresult;
39890 }
39891
39892
39893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
39894   void * jresult ;
39895   Dali::BaseHandle arg1 ;
39896   Dali::BaseHandle *argp1 ;
39897   Dali::EncodedBufferImage result;
39898
39899   argp1 = (Dali::BaseHandle *)jarg1;
39900   if (!argp1) {
39901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39902     return 0;
39903   }
39904   arg1 = *argp1;
39905   {
39906     try {
39907       result = Dali::EncodedBufferImage::DownCast(arg1);
39908     } catch (std::out_of_range& e) {
39909       {
39910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39911       };
39912     } catch (std::exception& e) {
39913       {
39914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39915       };
39916     } catch (...) {
39917       {
39918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39919       };
39920     }
39921   }
39922   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
39923   return jresult;
39924 }
39925
39926
39927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
39928   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
39929
39930   arg1 = (Dali::EncodedBufferImage *)jarg1;
39931   {
39932     try {
39933       delete arg1;
39934     } catch (std::out_of_range& e) {
39935       {
39936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39937       };
39938     } catch (std::exception& e) {
39939       {
39940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39941       };
39942     } catch (...) {
39943       {
39944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39945       };
39946     }
39947   }
39948 }
39949
39950
39951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
39952   void * jresult ;
39953   Dali::EncodedBufferImage *arg1 = 0 ;
39954   Dali::EncodedBufferImage *result = 0 ;
39955
39956   arg1 = (Dali::EncodedBufferImage *)jarg1;
39957   if (!arg1) {
39958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
39959     return 0;
39960   }
39961   {
39962     try {
39963       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
39964     } catch (std::out_of_range& e) {
39965       {
39966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39967       };
39968     } catch (std::exception& e) {
39969       {
39970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39971       };
39972     } catch (...) {
39973       {
39974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39975       };
39976     }
39977   }
39978   jresult = (void *)result;
39979   return jresult;
39980 }
39981
39982
39983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
39984   void * jresult ;
39985   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
39986   Dali::EncodedBufferImage *arg2 = 0 ;
39987   Dali::EncodedBufferImage *result = 0 ;
39988
39989   arg1 = (Dali::EncodedBufferImage *)jarg1;
39990   arg2 = (Dali::EncodedBufferImage *)jarg2;
39991   if (!arg2) {
39992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
39993     return 0;
39994   }
39995   {
39996     try {
39997       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
39998     } catch (std::out_of_range& e) {
39999       {
40000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40001       };
40002     } catch (std::exception& e) {
40003       {
40004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40005       };
40006     } catch (...) {
40007       {
40008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40009       };
40010     }
40011   }
40012   jresult = (void *)result;
40013   return jresult;
40014 }
40015
40016
40017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
40018   void * jresult ;
40019   Dali::NativeImage *result = 0 ;
40020
40021   {
40022     try {
40023       result = (Dali::NativeImage *)new Dali::NativeImage();
40024     } catch (std::out_of_range& e) {
40025       {
40026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40027       };
40028     } catch (std::exception& e) {
40029       {
40030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40031       };
40032     } catch (...) {
40033       {
40034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40035       };
40036     }
40037   }
40038   jresult = (void *)result;
40039   return jresult;
40040 }
40041
40042
40043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
40044   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
40045
40046   arg1 = (Dali::NativeImage *)jarg1;
40047   {
40048     try {
40049       delete arg1;
40050     } catch (std::out_of_range& e) {
40051       {
40052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40053       };
40054     } catch (std::exception& e) {
40055       {
40056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40057       };
40058     } catch (...) {
40059       {
40060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40061       };
40062     }
40063   }
40064 }
40065
40066
40067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
40068   void * jresult ;
40069   Dali::NativeImage *arg1 = 0 ;
40070   Dali::NativeImage *result = 0 ;
40071
40072   arg1 = (Dali::NativeImage *)jarg1;
40073   if (!arg1) {
40074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
40075     return 0;
40076   }
40077   {
40078     try {
40079       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
40080     } catch (std::out_of_range& e) {
40081       {
40082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40083       };
40084     } catch (std::exception& e) {
40085       {
40086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40087       };
40088     } catch (...) {
40089       {
40090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40091       };
40092     }
40093   }
40094   jresult = (void *)result;
40095   return jresult;
40096 }
40097
40098
40099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
40100   void * jresult ;
40101   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
40102   Dali::NativeImage *arg2 = 0 ;
40103   Dali::NativeImage *result = 0 ;
40104
40105   arg1 = (Dali::NativeImage *)jarg1;
40106   arg2 = (Dali::NativeImage *)jarg2;
40107   if (!arg2) {
40108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
40109     return 0;
40110   }
40111   {
40112     try {
40113       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
40114     } catch (std::out_of_range& e) {
40115       {
40116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40117       };
40118     } catch (std::exception& e) {
40119       {
40120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40121       };
40122     } catch (...) {
40123       {
40124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40125       };
40126     }
40127   }
40128   jresult = (void *)result;
40129   return jresult;
40130 }
40131
40132
40133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
40134   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
40135
40136   arg1 = (Dali::NativeImage *)jarg1;
40137   {
40138     try {
40139       (arg1)->CreateGlTexture();
40140     } catch (std::out_of_range& e) {
40141       {
40142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40143       };
40144     } catch (std::exception& e) {
40145       {
40146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40147       };
40148     } catch (...) {
40149       {
40150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40151       };
40152     }
40153   }
40154 }
40155
40156
40157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
40158   void * jresult ;
40159   NativeImageInterface *arg1 = 0 ;
40160   Dali::NativeImage result;
40161
40162   arg1 = (NativeImageInterface *)jarg1;
40163   if (!arg1) {
40164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
40165     return 0;
40166   }
40167   {
40168     try {
40169       result = Dali::NativeImage::New(*arg1);
40170     } catch (std::out_of_range& e) {
40171       {
40172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40173       };
40174     } catch (std::exception& e) {
40175       {
40176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40177       };
40178     } catch (...) {
40179       {
40180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40181       };
40182     }
40183   }
40184   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
40185   return jresult;
40186 }
40187
40188
40189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
40190   void * jresult ;
40191   Dali::BaseHandle arg1 ;
40192   Dali::BaseHandle *argp1 ;
40193   Dali::NativeImage result;
40194
40195   argp1 = (Dali::BaseHandle *)jarg1;
40196   if (!argp1) {
40197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40198     return 0;
40199   }
40200   arg1 = *argp1;
40201   {
40202     try {
40203       result = Dali::NativeImage::DownCast(arg1);
40204     } catch (std::out_of_range& e) {
40205       {
40206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40207       };
40208     } catch (std::exception& e) {
40209       {
40210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40211       };
40212     } catch (...) {
40213       {
40214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40215       };
40216     }
40217   }
40218   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
40219   return jresult;
40220 }
40221
40222
40223 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
40224   char * jresult ;
40225   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
40226   char *result = 0 ;
40227
40228   arg1 = (Dali::NativeImage *)jarg1;
40229   {
40230     try {
40231       result = (char *)(arg1)->GetCustomFragmentPreFix();
40232     } catch (std::out_of_range& e) {
40233       {
40234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40235       };
40236     } catch (std::exception& e) {
40237       {
40238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40239       };
40240     } catch (...) {
40241       {
40242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40243       };
40244     }
40245   }
40246   jresult = SWIG_csharp_string_callback((const char *)result);
40247   return jresult;
40248 }
40249
40250
40251 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
40252   char * jresult ;
40253   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
40254   char *result = 0 ;
40255
40256   arg1 = (Dali::NativeImage *)jarg1;
40257   {
40258     try {
40259       result = (char *)(arg1)->GetCustomSamplerTypename();
40260     } catch (std::out_of_range& e) {
40261       {
40262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40263       };
40264     } catch (std::exception& e) {
40265       {
40266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40267       };
40268     } catch (...) {
40269       {
40270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40271       };
40272     }
40273   }
40274   jresult = SWIG_csharp_string_callback((const char *)result);
40275   return jresult;
40276 }
40277
40278
40279 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
40280   unsigned int jresult ;
40281   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40282   bool result;
40283
40284   arg1 = (Dali::NativeImageInterface *)jarg1;
40285   {
40286     try {
40287       result = (bool)(arg1)->GlExtensionCreate();
40288     } catch (std::out_of_range& e) {
40289       {
40290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40291       };
40292     } catch (std::exception& e) {
40293       {
40294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40295       };
40296     } catch (...) {
40297       {
40298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40299       };
40300     }
40301   }
40302   jresult = result;
40303   return jresult;
40304 }
40305
40306
40307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
40308   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40309
40310   arg1 = (Dali::NativeImageInterface *)jarg1;
40311   {
40312     try {
40313       (arg1)->GlExtensionDestroy();
40314     } catch (std::out_of_range& e) {
40315       {
40316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40317       };
40318     } catch (std::exception& e) {
40319       {
40320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40321       };
40322     } catch (...) {
40323       {
40324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40325       };
40326     }
40327   }
40328 }
40329
40330
40331 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
40332   unsigned int jresult ;
40333   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40334   unsigned int result;
40335
40336   arg1 = (Dali::NativeImageInterface *)jarg1;
40337   {
40338     try {
40339       result = (unsigned int)(arg1)->TargetTexture();
40340     } catch (std::out_of_range& e) {
40341       {
40342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40343       };
40344     } catch (std::exception& e) {
40345       {
40346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40347       };
40348     } catch (...) {
40349       {
40350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40351       };
40352     }
40353   }
40354   jresult = result;
40355   return jresult;
40356 }
40357
40358
40359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
40360   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40361
40362   arg1 = (Dali::NativeImageInterface *)jarg1;
40363   {
40364     try {
40365       (arg1)->PrepareTexture();
40366     } catch (std::out_of_range& e) {
40367       {
40368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40369       };
40370     } catch (std::exception& e) {
40371       {
40372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40373       };
40374     } catch (...) {
40375       {
40376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40377       };
40378     }
40379   }
40380 }
40381
40382
40383 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
40384   unsigned int jresult ;
40385   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40386   unsigned int result;
40387
40388   arg1 = (Dali::NativeImageInterface *)jarg1;
40389   {
40390     try {
40391       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
40392     } catch (std::out_of_range& e) {
40393       {
40394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40395       };
40396     } catch (std::exception& e) {
40397       {
40398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40399       };
40400     } catch (...) {
40401       {
40402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40403       };
40404     }
40405   }
40406   jresult = result;
40407   return jresult;
40408 }
40409
40410
40411 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
40412   unsigned int jresult ;
40413   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40414   unsigned int result;
40415
40416   arg1 = (Dali::NativeImageInterface *)jarg1;
40417   {
40418     try {
40419       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
40420     } catch (std::out_of_range& e) {
40421       {
40422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40423       };
40424     } catch (std::exception& e) {
40425       {
40426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40427       };
40428     } catch (...) {
40429       {
40430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40431       };
40432     }
40433   }
40434   jresult = result;
40435   return jresult;
40436 }
40437
40438
40439 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
40440   unsigned int jresult ;
40441   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40442   bool result;
40443
40444   arg1 = (Dali::NativeImageInterface *)jarg1;
40445   {
40446     try {
40447       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
40448     } catch (std::out_of_range& e) {
40449       {
40450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40451       };
40452     } catch (std::exception& e) {
40453       {
40454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40455       };
40456     } catch (...) {
40457       {
40458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40459       };
40460     }
40461   }
40462   jresult = result;
40463   return jresult;
40464 }
40465
40466
40467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
40468   void * jresult ;
40469   std::string *arg1 = 0 ;
40470   Dali::ImageDimensions result;
40471
40472   if (!jarg1) {
40473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40474     return 0;
40475   }
40476   std::string arg1_str(jarg1);
40477   arg1 = &arg1_str;
40478   {
40479     try {
40480       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
40481     } catch (std::out_of_range& e) {
40482       {
40483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40484       };
40485     } catch (std::exception& e) {
40486       {
40487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40488       };
40489     } catch (...) {
40490       {
40491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40492       };
40493     }
40494   }
40495   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
40496
40497   //argout typemap for const std::string&
40498
40499   return jresult;
40500 }
40501
40502
40503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
40504   void * jresult ;
40505   Dali::ResourceImage *result = 0 ;
40506
40507   {
40508     try {
40509       result = (Dali::ResourceImage *)new Dali::ResourceImage();
40510     } catch (std::out_of_range& e) {
40511       {
40512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40513       };
40514     } catch (std::exception& e) {
40515       {
40516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40517       };
40518     } catch (...) {
40519       {
40520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40521       };
40522     }
40523   }
40524   jresult = (void *)result;
40525   return jresult;
40526 }
40527
40528
40529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
40530   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40531
40532   arg1 = (Dali::ResourceImage *)jarg1;
40533   {
40534     try {
40535       delete arg1;
40536     } catch (std::out_of_range& e) {
40537       {
40538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40539       };
40540     } catch (std::exception& e) {
40541       {
40542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40543       };
40544     } catch (...) {
40545       {
40546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40547       };
40548     }
40549   }
40550 }
40551
40552
40553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
40554   void * jresult ;
40555   Dali::ResourceImage *arg1 = 0 ;
40556   Dali::ResourceImage *result = 0 ;
40557
40558   arg1 = (Dali::ResourceImage *)jarg1;
40559   if (!arg1) {
40560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
40561     return 0;
40562   }
40563   {
40564     try {
40565       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*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 = (void *)result;
40581   return jresult;
40582 }
40583
40584
40585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
40586   void * jresult ;
40587   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40588   Dali::ResourceImage *arg2 = 0 ;
40589   Dali::ResourceImage *result = 0 ;
40590
40591   arg1 = (Dali::ResourceImage *)jarg1;
40592   arg2 = (Dali::ResourceImage *)jarg2;
40593   if (!arg2) {
40594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
40595     return 0;
40596   }
40597   {
40598     try {
40599       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
40600     } catch (std::out_of_range& e) {
40601       {
40602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40603       };
40604     } catch (std::exception& e) {
40605       {
40606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40607       };
40608     } catch (...) {
40609       {
40610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40611       };
40612     }
40613   }
40614   jresult = (void *)result;
40615   return jresult;
40616 }
40617
40618
40619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
40620   void * jresult ;
40621   std::string *arg1 = 0 ;
40622   bool arg2 ;
40623   Dali::ResourceImage result;
40624
40625   if (!jarg1) {
40626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40627     return 0;
40628   }
40629   std::string arg1_str(jarg1);
40630   arg1 = &arg1_str;
40631   arg2 = jarg2 ? true : false;
40632   {
40633     try {
40634       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
40635     } catch (std::out_of_range& e) {
40636       {
40637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40638       };
40639     } catch (std::exception& e) {
40640       {
40641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40642       };
40643     } catch (...) {
40644       {
40645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40646       };
40647     }
40648   }
40649   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40650
40651   //argout typemap for const std::string&
40652
40653   return jresult;
40654 }
40655
40656
40657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
40658   void * jresult ;
40659   std::string *arg1 = 0 ;
40660   Dali::ResourceImage result;
40661
40662   if (!jarg1) {
40663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40664     return 0;
40665   }
40666   std::string arg1_str(jarg1);
40667   arg1 = &arg1_str;
40668   {
40669     try {
40670       result = Dali::ResourceImage::New((std::string const &)*arg1);
40671     } catch (std::out_of_range& e) {
40672       {
40673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40674       };
40675     } catch (std::exception& e) {
40676       {
40677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40678       };
40679     } catch (...) {
40680       {
40681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40682       };
40683     }
40684   }
40685   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40686
40687   //argout typemap for const std::string&
40688
40689   return jresult;
40690 }
40691
40692
40693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
40694   void * jresult ;
40695   std::string *arg1 = 0 ;
40696   Dali::ImageDimensions arg2 ;
40697   Dali::FittingMode::Type arg3 ;
40698   Dali::SamplingMode::Type arg4 ;
40699   bool arg5 ;
40700   Dali::ImageDimensions *argp2 ;
40701   Dali::ResourceImage result;
40702
40703   if (!jarg1) {
40704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40705     return 0;
40706   }
40707   std::string arg1_str(jarg1);
40708   arg1 = &arg1_str;
40709   argp2 = (Dali::ImageDimensions *)jarg2;
40710   if (!argp2) {
40711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
40712     return 0;
40713   }
40714   arg2 = *argp2;
40715   arg3 = (Dali::FittingMode::Type)jarg3;
40716   arg4 = (Dali::SamplingMode::Type)jarg4;
40717   arg5 = jarg5 ? true : false;
40718   {
40719     try {
40720       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
40721     } catch (std::out_of_range& e) {
40722       {
40723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40724       };
40725     } catch (std::exception& e) {
40726       {
40727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40728       };
40729     } catch (...) {
40730       {
40731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40732       };
40733     }
40734   }
40735   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40736
40737   //argout typemap for const std::string&
40738
40739   return jresult;
40740 }
40741
40742
40743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
40744   void * jresult ;
40745   std::string *arg1 = 0 ;
40746   Dali::ImageDimensions arg2 ;
40747   Dali::FittingMode::Type arg3 ;
40748   Dali::SamplingMode::Type arg4 ;
40749   Dali::ImageDimensions *argp2 ;
40750   Dali::ResourceImage result;
40751
40752   if (!jarg1) {
40753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40754     return 0;
40755   }
40756   std::string arg1_str(jarg1);
40757   arg1 = &arg1_str;
40758   argp2 = (Dali::ImageDimensions *)jarg2;
40759   if (!argp2) {
40760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
40761     return 0;
40762   }
40763   arg2 = *argp2;
40764   arg3 = (Dali::FittingMode::Type)jarg3;
40765   arg4 = (Dali::SamplingMode::Type)jarg4;
40766   {
40767     try {
40768       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
40769     } catch (std::out_of_range& e) {
40770       {
40771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40772       };
40773     } catch (std::exception& e) {
40774       {
40775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40776       };
40777     } catch (...) {
40778       {
40779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40780       };
40781     }
40782   }
40783   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40784
40785   //argout typemap for const std::string&
40786
40787   return jresult;
40788 }
40789
40790
40791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
40792   void * jresult ;
40793   std::string *arg1 = 0 ;
40794   Dali::ImageDimensions arg2 ;
40795   Dali::FittingMode::Type arg3 ;
40796   Dali::ImageDimensions *argp2 ;
40797   Dali::ResourceImage result;
40798
40799   if (!jarg1) {
40800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40801     return 0;
40802   }
40803   std::string arg1_str(jarg1);
40804   arg1 = &arg1_str;
40805   argp2 = (Dali::ImageDimensions *)jarg2;
40806   if (!argp2) {
40807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
40808     return 0;
40809   }
40810   arg2 = *argp2;
40811   arg3 = (Dali::FittingMode::Type)jarg3;
40812   {
40813     try {
40814       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
40815     } catch (std::out_of_range& e) {
40816       {
40817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40818       };
40819     } catch (std::exception& e) {
40820       {
40821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40822       };
40823     } catch (...) {
40824       {
40825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40826       };
40827     }
40828   }
40829   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40830
40831   //argout typemap for const std::string&
40832
40833   return jresult;
40834 }
40835
40836
40837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
40838   void * jresult ;
40839   std::string *arg1 = 0 ;
40840   Dali::ImageDimensions arg2 ;
40841   Dali::ImageDimensions *argp2 ;
40842   Dali::ResourceImage result;
40843
40844   if (!jarg1) {
40845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40846     return 0;
40847   }
40848   std::string arg1_str(jarg1);
40849   arg1 = &arg1_str;
40850   argp2 = (Dali::ImageDimensions *)jarg2;
40851   if (!argp2) {
40852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
40853     return 0;
40854   }
40855   arg2 = *argp2;
40856   {
40857     try {
40858       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
40859     } catch (std::out_of_range& e) {
40860       {
40861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40862       };
40863     } catch (std::exception& e) {
40864       {
40865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40866       };
40867     } catch (...) {
40868       {
40869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40870       };
40871     }
40872   }
40873   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40874
40875   //argout typemap for const std::string&
40876
40877   return jresult;
40878 }
40879
40880
40881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
40882   void * jresult ;
40883   Dali::BaseHandle arg1 ;
40884   Dali::BaseHandle *argp1 ;
40885   Dali::ResourceImage result;
40886
40887   argp1 = (Dali::BaseHandle *)jarg1;
40888   if (!argp1) {
40889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40890     return 0;
40891   }
40892   arg1 = *argp1;
40893   {
40894     try {
40895       result = Dali::ResourceImage::DownCast(arg1);
40896     } catch (std::out_of_range& e) {
40897       {
40898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40899       };
40900     } catch (std::exception& e) {
40901       {
40902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40903       };
40904     } catch (...) {
40905       {
40906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40907       };
40908     }
40909   }
40910   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40911   return jresult;
40912 }
40913
40914
40915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
40916   int jresult ;
40917   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40918   Dali::LoadingState result;
40919
40920   arg1 = (Dali::ResourceImage *)jarg1;
40921   {
40922     try {
40923       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
40924     } catch (std::out_of_range& e) {
40925       {
40926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40927       };
40928     } catch (std::exception& e) {
40929       {
40930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40931       };
40932     } catch (...) {
40933       {
40934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40935       };
40936     }
40937   }
40938   jresult = (int)result;
40939   return jresult;
40940 }
40941
40942
40943 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
40944   char * jresult ;
40945   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40946   std::string result;
40947
40948   arg1 = (Dali::ResourceImage *)jarg1;
40949   {
40950     try {
40951       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
40952     } catch (std::out_of_range& e) {
40953       {
40954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40955       };
40956     } catch (std::exception& e) {
40957       {
40958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40959       };
40960     } catch (...) {
40961       {
40962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40963       };
40964     }
40965   }
40966   jresult = SWIG_csharp_string_callback((&result)->c_str());
40967   return jresult;
40968 }
40969
40970
40971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
40972   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40973
40974   arg1 = (Dali::ResourceImage *)jarg1;
40975   {
40976     try {
40977       (arg1)->Reload();
40978     } catch (std::out_of_range& e) {
40979       {
40980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40981       };
40982     } catch (std::exception& e) {
40983       {
40984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40985       };
40986     } catch (...) {
40987       {
40988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40989       };
40990     }
40991   }
40992 }
40993
40994
40995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
40996   void * jresult ;
40997   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40998   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
40999
41000   arg1 = (Dali::ResourceImage *)jarg1;
41001   {
41002     try {
41003       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
41004     } catch (std::out_of_range& e) {
41005       {
41006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41007       };
41008     } catch (std::exception& e) {
41009       {
41010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41011       };
41012     } catch (...) {
41013       {
41014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41015       };
41016     }
41017   }
41018   jresult = (void *)result;
41019   return jresult;
41020 }
41021
41022
41023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
41024   void * jresult ;
41025   Dali::FrameBufferImage *result = 0 ;
41026
41027   {
41028     try {
41029       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
41030     } catch (std::out_of_range& e) {
41031       {
41032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41033       };
41034     } catch (std::exception& e) {
41035       {
41036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41037       };
41038     } catch (...) {
41039       {
41040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41041       };
41042     }
41043   }
41044   jresult = (void *)result;
41045   return jresult;
41046 }
41047
41048
41049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
41050   void * jresult ;
41051   unsigned int arg1 ;
41052   unsigned int arg2 ;
41053   Dali::Pixel::Format arg3 ;
41054   Dali::RenderBuffer::Format arg4 ;
41055   Dali::FrameBufferImage result;
41056
41057   arg1 = (unsigned int)jarg1;
41058   arg2 = (unsigned int)jarg2;
41059   arg3 = (Dali::Pixel::Format)jarg3;
41060   arg4 = (Dali::RenderBuffer::Format)jarg4;
41061   {
41062     try {
41063       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
41064     } catch (std::out_of_range& e) {
41065       {
41066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41067       };
41068     } catch (std::exception& e) {
41069       {
41070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41071       };
41072     } catch (...) {
41073       {
41074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41075       };
41076     }
41077   }
41078   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41079   return jresult;
41080 }
41081
41082
41083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
41084   void * jresult ;
41085   unsigned int arg1 ;
41086   unsigned int arg2 ;
41087   Dali::Pixel::Format arg3 ;
41088   Dali::FrameBufferImage result;
41089
41090   arg1 = (unsigned int)jarg1;
41091   arg2 = (unsigned int)jarg2;
41092   arg3 = (Dali::Pixel::Format)jarg3;
41093   {
41094     try {
41095       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
41096     } catch (std::out_of_range& e) {
41097       {
41098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41099       };
41100     } catch (std::exception& e) {
41101       {
41102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41103       };
41104     } catch (...) {
41105       {
41106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41107       };
41108     }
41109   }
41110   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41111   return jresult;
41112 }
41113
41114
41115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
41116   void * jresult ;
41117   unsigned int arg1 ;
41118   unsigned int arg2 ;
41119   Dali::FrameBufferImage result;
41120
41121   arg1 = (unsigned int)jarg1;
41122   arg2 = (unsigned int)jarg2;
41123   {
41124     try {
41125       result = Dali::FrameBufferImage::New(arg1,arg2);
41126     } catch (std::out_of_range& e) {
41127       {
41128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41129       };
41130     } catch (std::exception& e) {
41131       {
41132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41133       };
41134     } catch (...) {
41135       {
41136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41137       };
41138     }
41139   }
41140   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41141   return jresult;
41142 }
41143
41144
41145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
41146   void * jresult ;
41147   unsigned int arg1 ;
41148   Dali::FrameBufferImage result;
41149
41150   arg1 = (unsigned int)jarg1;
41151   {
41152     try {
41153       result = Dali::FrameBufferImage::New(arg1);
41154     } catch (std::out_of_range& e) {
41155       {
41156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41157       };
41158     } catch (std::exception& e) {
41159       {
41160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41161       };
41162     } catch (...) {
41163       {
41164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41165       };
41166     }
41167   }
41168   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41169   return jresult;
41170 }
41171
41172
41173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
41174   void * jresult ;
41175   Dali::FrameBufferImage result;
41176
41177   {
41178     try {
41179       result = Dali::FrameBufferImage::New();
41180     } catch (std::out_of_range& e) {
41181       {
41182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41183       };
41184     } catch (std::exception& e) {
41185       {
41186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41187       };
41188     } catch (...) {
41189       {
41190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41191       };
41192     }
41193   }
41194   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41195   return jresult;
41196 }
41197
41198
41199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
41200   void * jresult ;
41201   Dali::NativeImageInterface *arg1 = 0 ;
41202   Dali::FrameBufferImage result;
41203
41204   arg1 = (Dali::NativeImageInterface *)jarg1;
41205   if (!arg1) {
41206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
41207     return 0;
41208   }
41209   {
41210     try {
41211       result = Dali::FrameBufferImage::New(*arg1);
41212     } catch (std::out_of_range& e) {
41213       {
41214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41215       };
41216     } catch (std::exception& e) {
41217       {
41218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41219       };
41220     } catch (...) {
41221       {
41222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41223       };
41224     }
41225   }
41226   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41227   return jresult;
41228 }
41229
41230
41231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
41232   void * jresult ;
41233   Dali::BaseHandle arg1 ;
41234   Dali::BaseHandle *argp1 ;
41235   Dali::FrameBufferImage result;
41236
41237   argp1 = (Dali::BaseHandle *)jarg1;
41238   if (!argp1) {
41239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41240     return 0;
41241   }
41242   arg1 = *argp1;
41243   {
41244     try {
41245       result = Dali::FrameBufferImage::DownCast(arg1);
41246     } catch (std::out_of_range& e) {
41247       {
41248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41249       };
41250     } catch (std::exception& e) {
41251       {
41252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41253       };
41254     } catch (...) {
41255       {
41256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41257       };
41258     }
41259   }
41260   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41261   return jresult;
41262 }
41263
41264
41265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
41266   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
41267
41268   arg1 = (Dali::FrameBufferImage *)jarg1;
41269   {
41270     try {
41271       delete arg1;
41272     } catch (std::out_of_range& e) {
41273       {
41274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41275       };
41276     } catch (std::exception& e) {
41277       {
41278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41279       };
41280     } catch (...) {
41281       {
41282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41283       };
41284     }
41285   }
41286 }
41287
41288
41289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
41290   void * jresult ;
41291   Dali::FrameBufferImage *arg1 = 0 ;
41292   Dali::FrameBufferImage *result = 0 ;
41293
41294   arg1 = (Dali::FrameBufferImage *)jarg1;
41295   if (!arg1) {
41296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
41297     return 0;
41298   }
41299   {
41300     try {
41301       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
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 = (void *)result;
41317   return jresult;
41318 }
41319
41320
41321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
41322   void * jresult ;
41323   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
41324   Dali::FrameBufferImage *arg2 = 0 ;
41325   Dali::FrameBufferImage *result = 0 ;
41326
41327   arg1 = (Dali::FrameBufferImage *)jarg1;
41328   arg2 = (Dali::FrameBufferImage *)jarg2;
41329   if (!arg2) {
41330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
41331     return 0;
41332   }
41333   {
41334     try {
41335       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
41336     } catch (std::out_of_range& e) {
41337       {
41338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41339       };
41340     } catch (std::exception& e) {
41341       {
41342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41343       };
41344     } catch (...) {
41345       {
41346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41347       };
41348     }
41349   }
41350   jresult = (void *)result;
41351   return jresult;
41352 }
41353
41354
41355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
41356   void * jresult ;
41357   Dali::NinePatchImage *result = 0 ;
41358
41359   {
41360     try {
41361       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
41362     } catch (std::out_of_range& e) {
41363       {
41364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41365       };
41366     } catch (std::exception& e) {
41367       {
41368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41369       };
41370     } catch (...) {
41371       {
41372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41373       };
41374     }
41375   }
41376   jresult = (void *)result;
41377   return jresult;
41378 }
41379
41380
41381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
41382   void * jresult ;
41383   std::string *arg1 = 0 ;
41384   Dali::NinePatchImage result;
41385
41386   if (!jarg1) {
41387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
41388     return 0;
41389   }
41390   std::string arg1_str(jarg1);
41391   arg1 = &arg1_str;
41392   {
41393     try {
41394       result = Dali::NinePatchImage::New((std::string const &)*arg1);
41395     } catch (std::out_of_range& e) {
41396       {
41397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41398       };
41399     } catch (std::exception& e) {
41400       {
41401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41402       };
41403     } catch (...) {
41404       {
41405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41406       };
41407     }
41408   }
41409   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
41410
41411   //argout typemap for const std::string&
41412
41413   return jresult;
41414 }
41415
41416
41417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
41418   void * jresult ;
41419   Dali::BaseHandle arg1 ;
41420   Dali::BaseHandle *argp1 ;
41421   Dali::NinePatchImage result;
41422
41423   argp1 = (Dali::BaseHandle *)jarg1;
41424   if (!argp1) {
41425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41426     return 0;
41427   }
41428   arg1 = *argp1;
41429   {
41430     try {
41431       result = Dali::NinePatchImage::DownCast(arg1);
41432     } catch (std::out_of_range& e) {
41433       {
41434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41435       };
41436     } catch (std::exception& e) {
41437       {
41438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41439       };
41440     } catch (...) {
41441       {
41442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41443       };
41444     }
41445   }
41446   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
41447   return jresult;
41448 }
41449
41450
41451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
41452   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41453
41454   arg1 = (Dali::NinePatchImage *)jarg1;
41455   {
41456     try {
41457       delete arg1;
41458     } catch (std::out_of_range& e) {
41459       {
41460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41461       };
41462     } catch (std::exception& e) {
41463       {
41464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41465       };
41466     } catch (...) {
41467       {
41468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41469       };
41470     }
41471   }
41472 }
41473
41474
41475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
41476   void * jresult ;
41477   Dali::NinePatchImage *arg1 = 0 ;
41478   Dali::NinePatchImage *result = 0 ;
41479
41480   arg1 = (Dali::NinePatchImage *)jarg1;
41481   if (!arg1) {
41482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
41483     return 0;
41484   }
41485   {
41486     try {
41487       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
41488     } catch (std::out_of_range& e) {
41489       {
41490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41491       };
41492     } catch (std::exception& e) {
41493       {
41494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41495       };
41496     } catch (...) {
41497       {
41498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41499       };
41500     }
41501   }
41502   jresult = (void *)result;
41503   return jresult;
41504 }
41505
41506
41507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
41508   void * jresult ;
41509   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41510   Dali::NinePatchImage *arg2 = 0 ;
41511   Dali::NinePatchImage *result = 0 ;
41512
41513   arg1 = (Dali::NinePatchImage *)jarg1;
41514   arg2 = (Dali::NinePatchImage *)jarg2;
41515   if (!arg2) {
41516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
41517     return 0;
41518   }
41519   {
41520     try {
41521       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
41522     } catch (std::out_of_range& e) {
41523       {
41524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41525       };
41526     } catch (std::exception& e) {
41527       {
41528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41529       };
41530     } catch (...) {
41531       {
41532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41533       };
41534     }
41535   }
41536   jresult = (void *)result;
41537   return jresult;
41538 }
41539
41540
41541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
41542   void * jresult ;
41543   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41544   Dali::Vector4 result;
41545
41546   arg1 = (Dali::NinePatchImage *)jarg1;
41547   {
41548     try {
41549       result = (arg1)->GetStretchBorders();
41550     } catch (std::out_of_range& e) {
41551       {
41552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41553       };
41554     } catch (std::exception& e) {
41555       {
41556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41557       };
41558     } catch (...) {
41559       {
41560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41561       };
41562     }
41563   }
41564   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
41565   return jresult;
41566 }
41567
41568
41569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
41570   void * jresult ;
41571   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41572   Dali::NinePatchImage::StretchRanges *result = 0 ;
41573
41574   arg1 = (Dali::NinePatchImage *)jarg1;
41575   {
41576     try {
41577       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
41578     } catch (std::out_of_range& e) {
41579       {
41580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41581       };
41582     } catch (std::exception& e) {
41583       {
41584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41585       };
41586     } catch (...) {
41587       {
41588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41589       };
41590     }
41591   }
41592   jresult = (void *)result;
41593   return jresult;
41594 }
41595
41596
41597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
41598   void * jresult ;
41599   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41600   Dali::NinePatchImage::StretchRanges *result = 0 ;
41601
41602   arg1 = (Dali::NinePatchImage *)jarg1;
41603   {
41604     try {
41605       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
41606     } catch (std::out_of_range& e) {
41607       {
41608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41609       };
41610     } catch (std::exception& e) {
41611       {
41612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41613       };
41614     } catch (...) {
41615       {
41616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41617       };
41618     }
41619   }
41620   jresult = (void *)result;
41621   return jresult;
41622 }
41623
41624
41625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
41626   void * jresult ;
41627   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41628   Dali::Rect< int > result;
41629
41630   arg1 = (Dali::NinePatchImage *)jarg1;
41631   {
41632     try {
41633       result = (arg1)->GetChildRectangle();
41634     } catch (std::out_of_range& e) {
41635       {
41636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41637       };
41638     } catch (std::exception& e) {
41639       {
41640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41641       };
41642     } catch (...) {
41643       {
41644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41645       };
41646     }
41647   }
41648   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
41649   return jresult;
41650 }
41651
41652
41653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
41654   void * jresult ;
41655   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41656   Dali::BufferImage result;
41657
41658   arg1 = (Dali::NinePatchImage *)jarg1;
41659   {
41660     try {
41661       result = (arg1)->CreateCroppedBufferImage();
41662     } catch (std::out_of_range& e) {
41663       {
41664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41665       };
41666     } catch (std::exception& e) {
41667       {
41668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41669       };
41670     } catch (...) {
41671       {
41672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41673       };
41674     }
41675   }
41676   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41677   return jresult;
41678 }
41679
41680
41681 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
41682   unsigned int jresult ;
41683   std::string *arg1 = 0 ;
41684   bool result;
41685
41686   if (!jarg1) {
41687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
41688     return 0;
41689   }
41690   std::string arg1_str(jarg1);
41691   arg1 = &arg1_str;
41692   {
41693     try {
41694       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
41695     } catch (std::out_of_range& e) {
41696       {
41697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41698       };
41699     } catch (std::exception& e) {
41700       {
41701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41702       };
41703     } catch (...) {
41704       {
41705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41706       };
41707     }
41708   }
41709   jresult = result;
41710
41711   //argout typemap for const std::string&
41712
41713   return jresult;
41714 }
41715
41716
41717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
41718   int jresult ;
41719   int result;
41720
41721   result = (int)Dali::CameraActor::Property::TYPE;
41722   jresult = (int)result;
41723   return jresult;
41724 }
41725
41726
41727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
41728   int jresult ;
41729   int result;
41730
41731   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
41732   jresult = (int)result;
41733   return jresult;
41734 }
41735
41736
41737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
41738   int jresult ;
41739   int result;
41740
41741   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
41742   jresult = (int)result;
41743   return jresult;
41744 }
41745
41746
41747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
41748   int jresult ;
41749   int result;
41750
41751   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
41752   jresult = (int)result;
41753   return jresult;
41754 }
41755
41756
41757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
41758   int jresult ;
41759   int result;
41760
41761   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
41762   jresult = (int)result;
41763   return jresult;
41764 }
41765
41766
41767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
41768   int jresult ;
41769   int result;
41770
41771   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
41772   jresult = (int)result;
41773   return jresult;
41774 }
41775
41776
41777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
41778   int jresult ;
41779   int result;
41780
41781   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
41782   jresult = (int)result;
41783   return jresult;
41784 }
41785
41786
41787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
41788   int jresult ;
41789   int result;
41790
41791   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
41792   jresult = (int)result;
41793   return jresult;
41794 }
41795
41796
41797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
41798   int jresult ;
41799   int result;
41800
41801   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
41802   jresult = (int)result;
41803   return jresult;
41804 }
41805
41806
41807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
41808   int jresult ;
41809   int result;
41810
41811   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
41812   jresult = (int)result;
41813   return jresult;
41814 }
41815
41816
41817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
41818   int jresult ;
41819   int result;
41820
41821   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
41822   jresult = (int)result;
41823   return jresult;
41824 }
41825
41826
41827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
41828   int jresult ;
41829   int result;
41830
41831   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
41832   jresult = (int)result;
41833   return jresult;
41834 }
41835
41836
41837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
41838   int jresult ;
41839   int result;
41840
41841   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
41842   jresult = (int)result;
41843   return jresult;
41844 }
41845
41846
41847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
41848   int jresult ;
41849   int result;
41850
41851   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
41852   jresult = (int)result;
41853   return jresult;
41854 }
41855
41856
41857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
41858   void * jresult ;
41859   Dali::CameraActor::Property *result = 0 ;
41860
41861   {
41862     try {
41863       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
41864     } catch (std::out_of_range& e) {
41865       {
41866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41867       };
41868     } catch (std::exception& e) {
41869       {
41870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41871       };
41872     } catch (...) {
41873       {
41874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41875       };
41876     }
41877   }
41878   jresult = (void *)result;
41879   return jresult;
41880 }
41881
41882
41883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
41884   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
41885
41886   arg1 = (Dali::CameraActor::Property *)jarg1;
41887   {
41888     try {
41889       delete arg1;
41890     } catch (std::out_of_range& e) {
41891       {
41892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41893       };
41894     } catch (std::exception& e) {
41895       {
41896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41897       };
41898     } catch (...) {
41899       {
41900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41901       };
41902     }
41903   }
41904 }
41905
41906
41907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
41908   void * jresult ;
41909   Dali::CameraActor *result = 0 ;
41910
41911   {
41912     try {
41913       result = (Dali::CameraActor *)new Dali::CameraActor();
41914     } catch (std::out_of_range& e) {
41915       {
41916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41917       };
41918     } catch (std::exception& e) {
41919       {
41920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41921       };
41922     } catch (...) {
41923       {
41924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41925       };
41926     }
41927   }
41928   jresult = (void *)result;
41929   return jresult;
41930 }
41931
41932
41933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
41934   void * jresult ;
41935   Dali::CameraActor result;
41936
41937   {
41938     try {
41939       result = Dali::CameraActor::New();
41940     } catch (std::out_of_range& e) {
41941       {
41942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41943       };
41944     } catch (std::exception& e) {
41945       {
41946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41947       };
41948     } catch (...) {
41949       {
41950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41951       };
41952     }
41953   }
41954   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
41955   return jresult;
41956 }
41957
41958
41959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
41960   void * jresult ;
41961   Dali::Size *arg1 = 0 ;
41962   Dali::CameraActor result;
41963
41964   arg1 = (Dali::Size *)jarg1;
41965   if (!arg1) {
41966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
41967     return 0;
41968   }
41969   {
41970     try {
41971       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
41972     } catch (std::out_of_range& e) {
41973       {
41974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41975       };
41976     } catch (std::exception& e) {
41977       {
41978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41979       };
41980     } catch (...) {
41981       {
41982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41983       };
41984     }
41985   }
41986   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
41987   return jresult;
41988 }
41989
41990
41991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
41992   void * jresult ;
41993   Dali::BaseHandle arg1 ;
41994   Dali::BaseHandle *argp1 ;
41995   Dali::CameraActor result;
41996
41997   argp1 = (Dali::BaseHandle *)jarg1;
41998   if (!argp1) {
41999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42000     return 0;
42001   }
42002   arg1 = *argp1;
42003   {
42004     try {
42005       result = Dali::CameraActor::DownCast(arg1);
42006     } catch (std::out_of_range& e) {
42007       {
42008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42009       };
42010     } catch (std::exception& e) {
42011       {
42012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42013       };
42014     } catch (...) {
42015       {
42016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42017       };
42018     }
42019   }
42020   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
42021   return jresult;
42022 }
42023
42024
42025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
42026   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42027
42028   arg1 = (Dali::CameraActor *)jarg1;
42029   {
42030     try {
42031       delete arg1;
42032     } catch (std::out_of_range& e) {
42033       {
42034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42035       };
42036     } catch (std::exception& e) {
42037       {
42038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42039       };
42040     } catch (...) {
42041       {
42042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42043       };
42044     }
42045   }
42046 }
42047
42048
42049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
42050   void * jresult ;
42051   Dali::CameraActor *arg1 = 0 ;
42052   Dali::CameraActor *result = 0 ;
42053
42054   arg1 = (Dali::CameraActor *)jarg1;
42055   if (!arg1) {
42056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
42057     return 0;
42058   }
42059   {
42060     try {
42061       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
42062     } catch (std::out_of_range& e) {
42063       {
42064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42065       };
42066     } catch (std::exception& e) {
42067       {
42068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42069       };
42070     } catch (...) {
42071       {
42072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42073       };
42074     }
42075   }
42076   jresult = (void *)result;
42077   return jresult;
42078 }
42079
42080
42081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
42082   void * jresult ;
42083   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42084   Dali::CameraActor *arg2 = 0 ;
42085   Dali::CameraActor *result = 0 ;
42086
42087   arg1 = (Dali::CameraActor *)jarg1;
42088   arg2 = (Dali::CameraActor *)jarg2;
42089   if (!arg2) {
42090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
42091     return 0;
42092   }
42093   {
42094     try {
42095       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
42096     } catch (std::out_of_range& e) {
42097       {
42098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42099       };
42100     } catch (std::exception& e) {
42101       {
42102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42103       };
42104     } catch (...) {
42105       {
42106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42107       };
42108     }
42109   }
42110   jresult = (void *)result;
42111   return jresult;
42112 }
42113
42114
42115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
42116   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42117   Dali::Camera::Type arg2 ;
42118
42119   arg1 = (Dali::CameraActor *)jarg1;
42120   arg2 = (Dali::Camera::Type)jarg2;
42121   {
42122     try {
42123       (arg1)->SetType(arg2);
42124     } catch (std::out_of_range& e) {
42125       {
42126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42127       };
42128     } catch (std::exception& e) {
42129       {
42130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42131       };
42132     } catch (...) {
42133       {
42134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42135       };
42136     }
42137   }
42138 }
42139
42140
42141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
42142   int jresult ;
42143   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42144   Dali::Camera::Type result;
42145
42146   arg1 = (Dali::CameraActor *)jarg1;
42147   {
42148     try {
42149       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
42150     } catch (std::out_of_range& e) {
42151       {
42152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42153       };
42154     } catch (std::exception& e) {
42155       {
42156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42157       };
42158     } catch (...) {
42159       {
42160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42161       };
42162     }
42163   }
42164   jresult = (int)result;
42165   return jresult;
42166 }
42167
42168
42169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
42170   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42171   Dali::Camera::ProjectionMode arg2 ;
42172
42173   arg1 = (Dali::CameraActor *)jarg1;
42174   arg2 = (Dali::Camera::ProjectionMode)jarg2;
42175   {
42176     try {
42177       (arg1)->SetProjectionMode(arg2);
42178     } catch (std::out_of_range& e) {
42179       {
42180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42181       };
42182     } catch (std::exception& e) {
42183       {
42184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42185       };
42186     } catch (...) {
42187       {
42188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42189       };
42190     }
42191   }
42192 }
42193
42194
42195 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
42196   int jresult ;
42197   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42198   Dali::Camera::ProjectionMode result;
42199
42200   arg1 = (Dali::CameraActor *)jarg1;
42201   {
42202     try {
42203       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
42204     } catch (std::out_of_range& e) {
42205       {
42206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42207       };
42208     } catch (std::exception& e) {
42209       {
42210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42211       };
42212     } catch (...) {
42213       {
42214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42215       };
42216     }
42217   }
42218   jresult = (int)result;
42219   return jresult;
42220 }
42221
42222
42223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
42224   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42225   float arg2 ;
42226
42227   arg1 = (Dali::CameraActor *)jarg1;
42228   arg2 = (float)jarg2;
42229   {
42230     try {
42231       (arg1)->SetFieldOfView(arg2);
42232     } catch (std::out_of_range& e) {
42233       {
42234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42235       };
42236     } catch (std::exception& e) {
42237       {
42238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42239       };
42240     } catch (...) {
42241       {
42242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42243       };
42244     }
42245   }
42246 }
42247
42248
42249 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
42250   float jresult ;
42251   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42252   float result;
42253
42254   arg1 = (Dali::CameraActor *)jarg1;
42255   {
42256     try {
42257       result = (float)(arg1)->GetFieldOfView();
42258     } catch (std::out_of_range& e) {
42259       {
42260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42261       };
42262     } catch (std::exception& e) {
42263       {
42264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42265       };
42266     } catch (...) {
42267       {
42268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42269       };
42270     }
42271   }
42272   jresult = result;
42273   return jresult;
42274 }
42275
42276
42277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
42278   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42279   float arg2 ;
42280
42281   arg1 = (Dali::CameraActor *)jarg1;
42282   arg2 = (float)jarg2;
42283   {
42284     try {
42285       (arg1)->SetAspectRatio(arg2);
42286     } catch (std::out_of_range& e) {
42287       {
42288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42289       };
42290     } catch (std::exception& e) {
42291       {
42292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42293       };
42294     } catch (...) {
42295       {
42296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42297       };
42298     }
42299   }
42300 }
42301
42302
42303 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
42304   float jresult ;
42305   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42306   float result;
42307
42308   arg1 = (Dali::CameraActor *)jarg1;
42309   {
42310     try {
42311       result = (float)(arg1)->GetAspectRatio();
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_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
42332   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42333   float arg2 ;
42334
42335   arg1 = (Dali::CameraActor *)jarg1;
42336   arg2 = (float)jarg2;
42337   {
42338     try {
42339       (arg1)->SetNearClippingPlane(arg2);
42340     } catch (std::out_of_range& e) {
42341       {
42342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42343       };
42344     } catch (std::exception& e) {
42345       {
42346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42347       };
42348     } catch (...) {
42349       {
42350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42351       };
42352     }
42353   }
42354 }
42355
42356
42357 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
42358   float jresult ;
42359   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42360   float result;
42361
42362   arg1 = (Dali::CameraActor *)jarg1;
42363   {
42364     try {
42365       result = (float)(arg1)->GetNearClippingPlane();
42366     } catch (std::out_of_range& e) {
42367       {
42368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42369       };
42370     } catch (std::exception& e) {
42371       {
42372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42373       };
42374     } catch (...) {
42375       {
42376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42377       };
42378     }
42379   }
42380   jresult = result;
42381   return jresult;
42382 }
42383
42384
42385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
42386   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42387   float arg2 ;
42388
42389   arg1 = (Dali::CameraActor *)jarg1;
42390   arg2 = (float)jarg2;
42391   {
42392     try {
42393       (arg1)->SetFarClippingPlane(arg2);
42394     } catch (std::out_of_range& e) {
42395       {
42396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42397       };
42398     } catch (std::exception& e) {
42399       {
42400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42401       };
42402     } catch (...) {
42403       {
42404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42405       };
42406     }
42407   }
42408 }
42409
42410
42411 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
42412   float jresult ;
42413   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42414   float result;
42415
42416   arg1 = (Dali::CameraActor *)jarg1;
42417   {
42418     try {
42419       result = (float)(arg1)->GetFarClippingPlane();
42420     } catch (std::out_of_range& e) {
42421       {
42422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42423       };
42424     } catch (std::exception& e) {
42425       {
42426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42427       };
42428     } catch (...) {
42429       {
42430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42431       };
42432     }
42433   }
42434   jresult = result;
42435   return jresult;
42436 }
42437
42438
42439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
42440   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42441   Dali::Vector3 *arg2 = 0 ;
42442
42443   arg1 = (Dali::CameraActor *)jarg1;
42444   arg2 = (Dali::Vector3 *)jarg2;
42445   if (!arg2) {
42446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
42447     return ;
42448   }
42449   {
42450     try {
42451       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
42452     } catch (std::out_of_range& e) {
42453       {
42454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42455       };
42456     } catch (std::exception& e) {
42457       {
42458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42459       };
42460     } catch (...) {
42461       {
42462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42463       };
42464     }
42465   }
42466 }
42467
42468
42469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
42470   void * jresult ;
42471   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42472   Dali::Vector3 result;
42473
42474   arg1 = (Dali::CameraActor *)jarg1;
42475   {
42476     try {
42477       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
42478     } catch (std::out_of_range& e) {
42479       {
42480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42481       };
42482     } catch (std::exception& e) {
42483       {
42484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42485       };
42486     } catch (...) {
42487       {
42488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42489       };
42490     }
42491   }
42492   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
42493   return jresult;
42494 }
42495
42496
42497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
42498   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42499   bool arg2 ;
42500
42501   arg1 = (Dali::CameraActor *)jarg1;
42502   arg2 = jarg2 ? true : false;
42503   {
42504     try {
42505       (arg1)->SetInvertYAxis(arg2);
42506     } catch (std::out_of_range& e) {
42507       {
42508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42509       };
42510     } catch (std::exception& e) {
42511       {
42512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42513       };
42514     } catch (...) {
42515       {
42516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42517       };
42518     }
42519   }
42520 }
42521
42522
42523 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
42524   unsigned int jresult ;
42525   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42526   bool result;
42527
42528   arg1 = (Dali::CameraActor *)jarg1;
42529   {
42530     try {
42531       result = (bool)(arg1)->GetInvertYAxis();
42532     } catch (std::out_of_range& e) {
42533       {
42534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42535       };
42536     } catch (std::exception& e) {
42537       {
42538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42539       };
42540     } catch (...) {
42541       {
42542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42543       };
42544     }
42545   }
42546   jresult = result;
42547   return jresult;
42548 }
42549
42550
42551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
42552   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42553   Dali::Size *arg2 = 0 ;
42554
42555   arg1 = (Dali::CameraActor *)jarg1;
42556   arg2 = (Dali::Size *)jarg2;
42557   if (!arg2) {
42558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
42559     return ;
42560   }
42561   {
42562     try {
42563       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
42564     } catch (std::out_of_range& e) {
42565       {
42566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42567       };
42568     } catch (std::exception& e) {
42569       {
42570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42571       };
42572     } catch (...) {
42573       {
42574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42575       };
42576     }
42577   }
42578 }
42579
42580
42581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
42582   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42583   Dali::Size *arg2 = 0 ;
42584
42585   arg1 = (Dali::CameraActor *)jarg1;
42586   arg2 = (Dali::Size *)jarg2;
42587   if (!arg2) {
42588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
42589     return ;
42590   }
42591   {
42592     try {
42593       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
42594     } catch (std::out_of_range& e) {
42595       {
42596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42597       };
42598     } catch (std::exception& e) {
42599       {
42600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42601       };
42602     } catch (...) {
42603       {
42604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42605       };
42606     }
42607   }
42608 }
42609
42610
42611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
42612   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42613   float arg2 ;
42614   float arg3 ;
42615   float arg4 ;
42616   float arg5 ;
42617   float arg6 ;
42618   float arg7 ;
42619
42620   arg1 = (Dali::CameraActor *)jarg1;
42621   arg2 = (float)jarg2;
42622   arg3 = (float)jarg3;
42623   arg4 = (float)jarg4;
42624   arg5 = (float)jarg5;
42625   arg6 = (float)jarg6;
42626   arg7 = (float)jarg7;
42627   {
42628     try {
42629       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
42630     } catch (std::out_of_range& e) {
42631       {
42632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42633       };
42634     } catch (std::exception& e) {
42635       {
42636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42637       };
42638     } catch (...) {
42639       {
42640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42641       };
42642     }
42643   }
42644 }
42645
42646
42647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
42648   void * jresult ;
42649   std::pair< std::string,Dali::Property::Value > *result = 0 ;
42650
42651   {
42652     try {
42653       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
42654     } catch (std::out_of_range& e) {
42655       {
42656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42657       };
42658     } catch (std::exception& e) {
42659       {
42660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42661       };
42662     } catch (...) {
42663       {
42664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42665       };
42666     }
42667   }
42668   jresult = (void *)result;
42669   return jresult;
42670 }
42671
42672
42673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
42674   void * jresult ;
42675   std::string arg1 ;
42676   Dali::Property::Value arg2 ;
42677   Dali::Property::Value *argp2 ;
42678   std::pair< std::string,Dali::Property::Value > *result = 0 ;
42679
42680   if (!jarg1) {
42681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42682     return 0;
42683   }
42684   (&arg1)->assign(jarg1);
42685   argp2 = (Dali::Property::Value *)jarg2;
42686   if (!argp2) {
42687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
42688     return 0;
42689   }
42690   arg2 = *argp2;
42691   {
42692     try {
42693       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
42694     } catch (std::out_of_range& e) {
42695       {
42696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42697       };
42698     } catch (std::exception& e) {
42699       {
42700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42701       };
42702     } catch (...) {
42703       {
42704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42705       };
42706     }
42707   }
42708   jresult = (void *)result;
42709   return jresult;
42710 }
42711
42712
42713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
42714   void * jresult ;
42715   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
42716   std::pair< std::string,Dali::Property::Value > *result = 0 ;
42717
42718   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42719   if (!arg1) {
42720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
42721     return 0;
42722   }
42723   {
42724     try {
42725       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);
42726     } catch (std::out_of_range& e) {
42727       {
42728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42729       };
42730     } catch (std::exception& e) {
42731       {
42732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42733       };
42734     } catch (...) {
42735       {
42736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42737       };
42738     }
42739   }
42740   jresult = (void *)result;
42741   return jresult;
42742 }
42743
42744
42745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
42746   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
42747   std::string *arg2 = 0 ;
42748
42749   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42750   if (!jarg2) {
42751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42752     return ;
42753   }
42754   std::string arg2_str(jarg2);
42755   arg2 = &arg2_str;
42756   if (arg1) (arg1)->first = *arg2;
42757
42758   //argout typemap for const std::string&
42759
42760 }
42761
42762
42763 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
42764   char * jresult ;
42765   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
42766   std::string *result = 0 ;
42767
42768   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42769   result = (std::string *) & ((arg1)->first);
42770   jresult = SWIG_csharp_string_callback(result->c_str());
42771   return jresult;
42772 }
42773
42774
42775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
42776   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
42777   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
42778
42779   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42780   arg2 = (Dali::Property::Value *)jarg2;
42781   if (arg1) (arg1)->second = *arg2;
42782 }
42783
42784
42785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
42786   void * jresult ;
42787   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
42788   Dali::Property::Value *result = 0 ;
42789
42790   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42791   result = (Dali::Property::Value *)& ((arg1)->second);
42792   jresult = (void *)result;
42793   return jresult;
42794 }
42795
42796
42797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
42798   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
42799
42800   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42801   {
42802     try {
42803       delete arg1;
42804     } catch (std::out_of_range& e) {
42805       {
42806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42807       };
42808     } catch (std::exception& e) {
42809       {
42810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42811       };
42812     } catch (...) {
42813       {
42814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42815       };
42816     }
42817   }
42818 }
42819
42820
42821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
42822   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
42823
42824   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42825   {
42826     try {
42827       (arg1)->clear();
42828     } catch (std::out_of_range& e) {
42829       {
42830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42831       };
42832     } catch (std::exception& e) {
42833       {
42834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42835       };
42836     } catch (...) {
42837       {
42838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42839       };
42840     }
42841   }
42842 }
42843
42844
42845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
42846   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
42847   Dali::TouchPoint *arg2 = 0 ;
42848
42849   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42850   arg2 = (Dali::TouchPoint *)jarg2;
42851   if (!arg2) {
42852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
42853     return ;
42854   }
42855   {
42856     try {
42857       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
42858     } catch (std::out_of_range& e) {
42859       {
42860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42861       };
42862     } catch (std::exception& e) {
42863       {
42864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42865       };
42866     } catch (...) {
42867       {
42868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42869       };
42870     }
42871   }
42872 }
42873
42874
42875 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
42876   unsigned long jresult ;
42877   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
42878   std::vector< Dali::TouchPoint >::size_type result;
42879
42880   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42881   {
42882     try {
42883       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
42884     } catch (std::out_of_range& e) {
42885       {
42886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42887       };
42888     } catch (std::exception& e) {
42889       {
42890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42891       };
42892     } catch (...) {
42893       {
42894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42895       };
42896     }
42897   }
42898   jresult = (unsigned long)result;
42899   return jresult;
42900 }
42901
42902
42903 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
42904   unsigned long jresult ;
42905   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
42906   std::vector< Dali::TouchPoint >::size_type result;
42907
42908   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42909   {
42910     try {
42911       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
42912     } catch (std::out_of_range& e) {
42913       {
42914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42915       };
42916     } catch (std::exception& e) {
42917       {
42918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42919       };
42920     } catch (...) {
42921       {
42922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42923       };
42924     }
42925   }
42926   jresult = (unsigned long)result;
42927   return jresult;
42928 }
42929
42930
42931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
42932   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
42933   std::vector< Dali::TouchPoint >::size_type arg2 ;
42934
42935   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42936   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
42937   {
42938     try {
42939       (arg1)->reserve(arg2);
42940     } catch (std::out_of_range& e) {
42941       {
42942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42943       };
42944     } catch (std::exception& e) {
42945       {
42946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42947       };
42948     } catch (...) {
42949       {
42950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42951       };
42952     }
42953   }
42954 }
42955
42956
42957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
42958   void * jresult ;
42959   std::vector< Dali::TouchPoint > *result = 0 ;
42960
42961   {
42962     try {
42963       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
42964     } catch (std::out_of_range& e) {
42965       {
42966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42967       };
42968     } catch (std::exception& e) {
42969       {
42970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42971       };
42972     } catch (...) {
42973       {
42974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42975       };
42976     }
42977   }
42978   jresult = (void *)result;
42979   return jresult;
42980 }
42981
42982
42983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
42984   void * jresult ;
42985   std::vector< Dali::TouchPoint > *arg1 = 0 ;
42986   std::vector< Dali::TouchPoint > *result = 0 ;
42987
42988   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42989   if (!arg1) {
42990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
42991     return 0;
42992   }
42993   {
42994     try {
42995       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
42996     } catch (std::out_of_range& e) {
42997       {
42998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42999       };
43000     } catch (std::exception& e) {
43001       {
43002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43003       };
43004     } catch (...) {
43005       {
43006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43007       };
43008     }
43009   }
43010   jresult = (void *)result;
43011   return jresult;
43012 }
43013
43014
43015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
43016   void * jresult ;
43017   int arg1 ;
43018   std::vector< Dali::TouchPoint > *result = 0 ;
43019
43020   arg1 = (int)jarg1;
43021   {
43022     try {
43023       try {
43024         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
43025       }
43026       catch(std::out_of_range &_e) {
43027         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43028         return 0;
43029       }
43030
43031     } catch (std::out_of_range& e) {
43032       {
43033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43034       };
43035     } catch (std::exception& e) {
43036       {
43037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43038       };
43039     } catch (...) {
43040       {
43041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43042       };
43043     }
43044   }
43045   jresult = (void *)result;
43046   return jresult;
43047 }
43048
43049
43050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
43051   void * jresult ;
43052   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43053   int arg2 ;
43054   SwigValueWrapper< Dali::TouchPoint > result;
43055
43056   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43057   arg2 = (int)jarg2;
43058   {
43059     try {
43060       try {
43061         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
43062       }
43063       catch(std::out_of_range &_e) {
43064         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43065         return 0;
43066       }
43067
43068     } catch (std::out_of_range& e) {
43069       {
43070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43071       };
43072     } catch (std::exception& e) {
43073       {
43074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43075       };
43076     } catch (...) {
43077       {
43078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43079       };
43080     }
43081   }
43082   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
43083   return jresult;
43084 }
43085
43086
43087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
43088   void * jresult ;
43089   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43090   int arg2 ;
43091   Dali::TouchPoint *result = 0 ;
43092
43093   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43094   arg2 = (int)jarg2;
43095   {
43096     try {
43097       try {
43098         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
43099       }
43100       catch(std::out_of_range &_e) {
43101         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43102         return 0;
43103       }
43104
43105     } catch (std::out_of_range& e) {
43106       {
43107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43108       };
43109     } catch (std::exception& e) {
43110       {
43111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43112       };
43113     } catch (...) {
43114       {
43115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43116       };
43117     }
43118   }
43119   jresult = (void *)result;
43120   return jresult;
43121 }
43122
43123
43124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
43125   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43126   int arg2 ;
43127   Dali::TouchPoint *arg3 = 0 ;
43128
43129   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43130   arg2 = (int)jarg2;
43131   arg3 = (Dali::TouchPoint *)jarg3;
43132   if (!arg3) {
43133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
43134     return ;
43135   }
43136   {
43137     try {
43138       try {
43139         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
43140       }
43141       catch(std::out_of_range &_e) {
43142         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43143         return ;
43144       }
43145
43146     } catch (std::out_of_range& e) {
43147       {
43148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43149       };
43150     } catch (std::exception& e) {
43151       {
43152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43153       };
43154     } catch (...) {
43155       {
43156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43157       };
43158     }
43159   }
43160 }
43161
43162
43163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
43164   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43165   std::vector< Dali::TouchPoint > *arg2 = 0 ;
43166
43167   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43168   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
43169   if (!arg2) {
43170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
43171     return ;
43172   }
43173   {
43174     try {
43175       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
43176     } catch (std::out_of_range& e) {
43177       {
43178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43179       };
43180     } catch (std::exception& e) {
43181       {
43182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43183       };
43184     } catch (...) {
43185       {
43186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43187       };
43188     }
43189   }
43190 }
43191
43192
43193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
43194   void * jresult ;
43195   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43196   int arg2 ;
43197   int arg3 ;
43198   std::vector< Dali::TouchPoint > *result = 0 ;
43199
43200   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43201   arg2 = (int)jarg2;
43202   arg3 = (int)jarg3;
43203   {
43204     try {
43205       try {
43206         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
43207       }
43208       catch(std::out_of_range &_e) {
43209         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43210         return 0;
43211       }
43212       catch(std::invalid_argument &_e) {
43213         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
43214         return 0;
43215       }
43216
43217     } catch (std::out_of_range& e) {
43218       {
43219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43220       };
43221     } catch (std::exception& e) {
43222       {
43223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43224       };
43225     } catch (...) {
43226       {
43227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43228       };
43229     }
43230   }
43231   jresult = (void *)result;
43232   return jresult;
43233 }
43234
43235
43236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
43237   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43238   int arg2 ;
43239   Dali::TouchPoint *arg3 = 0 ;
43240
43241   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43242   arg2 = (int)jarg2;
43243   arg3 = (Dali::TouchPoint *)jarg3;
43244   if (!arg3) {
43245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
43246     return ;
43247   }
43248   {
43249     try {
43250       try {
43251         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
43252       }
43253       catch(std::out_of_range &_e) {
43254         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43255         return ;
43256       }
43257
43258     } catch (std::out_of_range& e) {
43259       {
43260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43261       };
43262     } catch (std::exception& e) {
43263       {
43264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43265       };
43266     } catch (...) {
43267       {
43268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43269       };
43270     }
43271   }
43272 }
43273
43274
43275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
43276   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43277   int arg2 ;
43278   std::vector< Dali::TouchPoint > *arg3 = 0 ;
43279
43280   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43281   arg2 = (int)jarg2;
43282   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
43283   if (!arg3) {
43284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
43285     return ;
43286   }
43287   {
43288     try {
43289       try {
43290         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
43291       }
43292       catch(std::out_of_range &_e) {
43293         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43294         return ;
43295       }
43296
43297     } catch (std::out_of_range& e) {
43298       {
43299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43300       };
43301     } catch (std::exception& e) {
43302       {
43303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43304       };
43305     } catch (...) {
43306       {
43307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43308       };
43309     }
43310   }
43311 }
43312
43313
43314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
43315   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43316   int arg2 ;
43317
43318   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43319   arg2 = (int)jarg2;
43320   {
43321     try {
43322       try {
43323         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
43324       }
43325       catch(std::out_of_range &_e) {
43326         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43327         return ;
43328       }
43329
43330     } catch (std::out_of_range& e) {
43331       {
43332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43333       };
43334     } catch (std::exception& e) {
43335       {
43336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43337       };
43338     } catch (...) {
43339       {
43340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43341       };
43342     }
43343   }
43344 }
43345
43346
43347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
43348   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43349   int arg2 ;
43350   int arg3 ;
43351
43352   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43353   arg2 = (int)jarg2;
43354   arg3 = (int)jarg3;
43355   {
43356     try {
43357       try {
43358         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
43359       }
43360       catch(std::out_of_range &_e) {
43361         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43362         return ;
43363       }
43364       catch(std::invalid_argument &_e) {
43365         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
43366         return ;
43367       }
43368
43369     } catch (std::out_of_range& e) {
43370       {
43371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43372       };
43373     } catch (std::exception& e) {
43374       {
43375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43376       };
43377     } catch (...) {
43378       {
43379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43380       };
43381     }
43382   }
43383 }
43384
43385
43386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
43387   void * jresult ;
43388   Dali::TouchPoint *arg1 = 0 ;
43389   int arg2 ;
43390   std::vector< Dali::TouchPoint > *result = 0 ;
43391
43392   arg1 = (Dali::TouchPoint *)jarg1;
43393   if (!arg1) {
43394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
43395     return 0;
43396   }
43397   arg2 = (int)jarg2;
43398   {
43399     try {
43400       try {
43401         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
43402       }
43403       catch(std::out_of_range &_e) {
43404         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43405         return 0;
43406       }
43407
43408     } catch (std::out_of_range& e) {
43409       {
43410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43411       };
43412     } catch (std::exception& e) {
43413       {
43414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43415       };
43416     } catch (...) {
43417       {
43418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43419       };
43420     }
43421   }
43422   jresult = (void *)result;
43423   return jresult;
43424 }
43425
43426
43427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
43428   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43429
43430   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43431   {
43432     try {
43433       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
43434     } catch (std::out_of_range& e) {
43435       {
43436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43437       };
43438     } catch (std::exception& e) {
43439       {
43440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43441       };
43442     } catch (...) {
43443       {
43444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43445       };
43446     }
43447   }
43448 }
43449
43450
43451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
43452   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43453   int arg2 ;
43454   int arg3 ;
43455
43456   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43457   arg2 = (int)jarg2;
43458   arg3 = (int)jarg3;
43459   {
43460     try {
43461       try {
43462         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
43463       }
43464       catch(std::out_of_range &_e) {
43465         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43466         return ;
43467       }
43468       catch(std::invalid_argument &_e) {
43469         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
43470         return ;
43471       }
43472
43473     } catch (std::out_of_range& e) {
43474       {
43475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43476       };
43477     } catch (std::exception& e) {
43478       {
43479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43480       };
43481     } catch (...) {
43482       {
43483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43484       };
43485     }
43486   }
43487 }
43488
43489
43490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
43491   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43492   int arg2 ;
43493   std::vector< Dali::TouchPoint > *arg3 = 0 ;
43494
43495   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43496   arg2 = (int)jarg2;
43497   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
43498   if (!arg3) {
43499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
43500     return ;
43501   }
43502   {
43503     try {
43504       try {
43505         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
43506       }
43507       catch(std::out_of_range &_e) {
43508         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43509         return ;
43510       }
43511
43512     } catch (std::out_of_range& e) {
43513       {
43514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43515       };
43516     } catch (std::exception& e) {
43517       {
43518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43519       };
43520     } catch (...) {
43521       {
43522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43523       };
43524     }
43525   }
43526 }
43527
43528
43529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
43530   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43531
43532   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43533   {
43534     try {
43535       delete arg1;
43536     } catch (std::out_of_range& e) {
43537       {
43538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43539       };
43540     } catch (std::exception& e) {
43541       {
43542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43543       };
43544     } catch (...) {
43545       {
43546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43547       };
43548     }
43549   }
43550 }
43551
43552
43553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
43554   void * jresult ;
43555   Dali::Rect< int > *result = 0 ;
43556
43557   {
43558     try {
43559       result = (Dali::Rect< int > *)new Dali::Rect< int >();
43560     } catch (std::out_of_range& e) {
43561       {
43562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43563       };
43564     } catch (std::exception& e) {
43565       {
43566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43567       };
43568     } catch (...) {
43569       {
43570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43571       };
43572     }
43573   }
43574   jresult = (void *)result;
43575   return jresult;
43576 }
43577
43578
43579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
43580   void * jresult ;
43581   int arg1 ;
43582   int arg2 ;
43583   int arg3 ;
43584   int arg4 ;
43585   Dali::Rect< int > *result = 0 ;
43586
43587   arg1 = (int)jarg1;
43588   arg2 = (int)jarg2;
43589   arg3 = (int)jarg3;
43590   arg4 = (int)jarg4;
43591   {
43592     try {
43593       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
43594     } catch (std::out_of_range& e) {
43595       {
43596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43597       };
43598     } catch (std::exception& e) {
43599       {
43600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43601       };
43602     } catch (...) {
43603       {
43604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43605       };
43606     }
43607   }
43608   jresult = (void *)result;
43609   return jresult;
43610 }
43611
43612
43613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
43614   void * jresult ;
43615   Dali::Rect< int > *arg1 = 0 ;
43616   Dali::Rect< int > *result = 0 ;
43617
43618   arg1 = (Dali::Rect< int > *)jarg1;
43619   if (!arg1) {
43620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
43621     return 0;
43622   }
43623   {
43624     try {
43625       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
43626     } catch (std::out_of_range& e) {
43627       {
43628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43629       };
43630     } catch (std::exception& e) {
43631       {
43632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43633       };
43634     } catch (...) {
43635       {
43636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43637       };
43638     }
43639   }
43640   jresult = (void *)result;
43641   return jresult;
43642 }
43643
43644
43645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
43646   void * jresult ;
43647   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43648   Dali::Rect< int > *arg2 = 0 ;
43649   Dali::Rect< int > *result = 0 ;
43650
43651   arg1 = (Dali::Rect< int > *)jarg1;
43652   arg2 = (Dali::Rect< int > *)jarg2;
43653   if (!arg2) {
43654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
43655     return 0;
43656   }
43657   {
43658     try {
43659       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
43660     } catch (std::out_of_range& e) {
43661       {
43662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43663       };
43664     } catch (std::exception& e) {
43665       {
43666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43667       };
43668     } catch (...) {
43669       {
43670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43671       };
43672     }
43673   }
43674   jresult = (void *)result;
43675   return jresult;
43676 }
43677
43678
43679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
43680   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43681   int arg2 ;
43682   int arg3 ;
43683   int arg4 ;
43684   int arg5 ;
43685
43686   arg1 = (Dali::Rect< int > *)jarg1;
43687   arg2 = (int)jarg2;
43688   arg3 = (int)jarg3;
43689   arg4 = (int)jarg4;
43690   arg5 = (int)jarg5;
43691   {
43692     try {
43693       (arg1)->Set(arg2,arg3,arg4,arg5);
43694     } catch (std::out_of_range& e) {
43695       {
43696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43697       };
43698     } catch (std::exception& e) {
43699       {
43700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43701       };
43702     } catch (...) {
43703       {
43704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43705       };
43706     }
43707   }
43708 }
43709
43710
43711 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
43712   unsigned int jresult ;
43713   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43714   bool result;
43715
43716   arg1 = (Dali::Rect< int > *)jarg1;
43717   {
43718     try {
43719       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
43720     } catch (std::out_of_range& e) {
43721       {
43722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43723       };
43724     } catch (std::exception& e) {
43725       {
43726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43727       };
43728     } catch (...) {
43729       {
43730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43731       };
43732     }
43733   }
43734   jresult = result;
43735   return jresult;
43736 }
43737
43738
43739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
43740   int jresult ;
43741   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43742   int result;
43743
43744   arg1 = (Dali::Rect< int > *)jarg1;
43745   {
43746     try {
43747       result = (int)((Dali::Rect< int > const *)arg1)->Left();
43748     } catch (std::out_of_range& e) {
43749       {
43750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43751       };
43752     } catch (std::exception& e) {
43753       {
43754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43755       };
43756     } catch (...) {
43757       {
43758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43759       };
43760     }
43761   }
43762   jresult = result;
43763   return jresult;
43764 }
43765
43766
43767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
43768   int jresult ;
43769   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43770   int result;
43771
43772   arg1 = (Dali::Rect< int > *)jarg1;
43773   {
43774     try {
43775       result = (int)((Dali::Rect< int > const *)arg1)->Right();
43776     } catch (std::out_of_range& e) {
43777       {
43778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43779       };
43780     } catch (std::exception& e) {
43781       {
43782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43783       };
43784     } catch (...) {
43785       {
43786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43787       };
43788     }
43789   }
43790   jresult = result;
43791   return jresult;
43792 }
43793
43794
43795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
43796   int jresult ;
43797   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43798   int result;
43799
43800   arg1 = (Dali::Rect< int > *)jarg1;
43801   {
43802     try {
43803       result = (int)((Dali::Rect< int > const *)arg1)->Top();
43804     } catch (std::out_of_range& e) {
43805       {
43806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43807       };
43808     } catch (std::exception& e) {
43809       {
43810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43811       };
43812     } catch (...) {
43813       {
43814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43815       };
43816     }
43817   }
43818   jresult = result;
43819   return jresult;
43820 }
43821
43822
43823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
43824   int jresult ;
43825   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43826   int result;
43827
43828   arg1 = (Dali::Rect< int > *)jarg1;
43829   {
43830     try {
43831       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
43832     } catch (std::out_of_range& e) {
43833       {
43834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43835       };
43836     } catch (std::exception& e) {
43837       {
43838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43839       };
43840     } catch (...) {
43841       {
43842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43843       };
43844     }
43845   }
43846   jresult = result;
43847   return jresult;
43848 }
43849
43850
43851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
43852   int jresult ;
43853   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43854   int result;
43855
43856   arg1 = (Dali::Rect< int > *)jarg1;
43857   {
43858     try {
43859       result = (int)((Dali::Rect< int > const *)arg1)->Area();
43860     } catch (std::out_of_range& e) {
43861       {
43862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43863       };
43864     } catch (std::exception& e) {
43865       {
43866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43867       };
43868     } catch (...) {
43869       {
43870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43871       };
43872     }
43873   }
43874   jresult = result;
43875   return jresult;
43876 }
43877
43878
43879 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
43880   unsigned int jresult ;
43881   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43882   Dali::Rect< int > *arg2 = 0 ;
43883   bool result;
43884
43885   arg1 = (Dali::Rect< int > *)jarg1;
43886   arg2 = (Dali::Rect< int > *)jarg2;
43887   if (!arg2) {
43888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
43889     return 0;
43890   }
43891   {
43892     try {
43893       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
43894     } catch (std::out_of_range& e) {
43895       {
43896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43897       };
43898     } catch (std::exception& e) {
43899       {
43900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43901       };
43902     } catch (...) {
43903       {
43904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43905       };
43906     }
43907   }
43908   jresult = result;
43909   return jresult;
43910 }
43911
43912
43913 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
43914   unsigned int jresult ;
43915   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43916   Dali::Rect< int > *arg2 = 0 ;
43917   bool result;
43918
43919   arg1 = (Dali::Rect< int > *)jarg1;
43920   arg2 = (Dali::Rect< int > *)jarg2;
43921   if (!arg2) {
43922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
43923     return 0;
43924   }
43925   {
43926     try {
43927       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
43928     } catch (std::out_of_range& e) {
43929       {
43930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43931       };
43932     } catch (std::exception& e) {
43933       {
43934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43935       };
43936     } catch (...) {
43937       {
43938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43939       };
43940     }
43941   }
43942   jresult = result;
43943   return jresult;
43944 }
43945
43946
43947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
43948   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43949   int arg2 ;
43950
43951   arg1 = (Dali::Rect< int > *)jarg1;
43952   arg2 = (int)jarg2;
43953   if (arg1) (arg1)->x = arg2;
43954 }
43955
43956
43957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
43958   int jresult ;
43959   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43960   int result;
43961
43962   arg1 = (Dali::Rect< int > *)jarg1;
43963   result = (int) ((arg1)->x);
43964   jresult = result;
43965   return jresult;
43966 }
43967
43968
43969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
43970   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43971   int arg2 ;
43972
43973   arg1 = (Dali::Rect< int > *)jarg1;
43974   arg2 = (int)jarg2;
43975   if (arg1) (arg1)->left = arg2;
43976 }
43977
43978
43979 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
43980   int jresult ;
43981   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43982   int result;
43983
43984   arg1 = (Dali::Rect< int > *)jarg1;
43985   result = (int) ((arg1)->left);
43986   jresult = result;
43987   return jresult;
43988 }
43989
43990
43991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
43992   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43993   int arg2 ;
43994
43995   arg1 = (Dali::Rect< int > *)jarg1;
43996   arg2 = (int)jarg2;
43997   if (arg1) (arg1)->y = arg2;
43998 }
43999
44000
44001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
44002   int jresult ;
44003   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44004   int result;
44005
44006   arg1 = (Dali::Rect< int > *)jarg1;
44007   result = (int) ((arg1)->y);
44008   jresult = result;
44009   return jresult;
44010 }
44011
44012
44013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
44014   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44015   int arg2 ;
44016
44017   arg1 = (Dali::Rect< int > *)jarg1;
44018   arg2 = (int)jarg2;
44019   if (arg1) (arg1)->right = arg2;
44020 }
44021
44022
44023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
44024   int jresult ;
44025   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44026   int result;
44027
44028   arg1 = (Dali::Rect< int > *)jarg1;
44029   result = (int) ((arg1)->right);
44030   jresult = result;
44031   return jresult;
44032 }
44033
44034
44035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
44036   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44037   int arg2 ;
44038
44039   arg1 = (Dali::Rect< int > *)jarg1;
44040   arg2 = (int)jarg2;
44041   if (arg1) (arg1)->width = arg2;
44042 }
44043
44044
44045 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
44046   int jresult ;
44047   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44048   int result;
44049
44050   arg1 = (Dali::Rect< int > *)jarg1;
44051   result = (int) ((arg1)->width);
44052   jresult = result;
44053   return jresult;
44054 }
44055
44056
44057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
44058   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44059   int arg2 ;
44060
44061   arg1 = (Dali::Rect< int > *)jarg1;
44062   arg2 = (int)jarg2;
44063   if (arg1) (arg1)->bottom = arg2;
44064 }
44065
44066
44067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
44068   int jresult ;
44069   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44070   int result;
44071
44072   arg1 = (Dali::Rect< int > *)jarg1;
44073   result = (int) ((arg1)->bottom);
44074   jresult = result;
44075   return jresult;
44076 }
44077
44078
44079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
44080   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44081   int arg2 ;
44082
44083   arg1 = (Dali::Rect< int > *)jarg1;
44084   arg2 = (int)jarg2;
44085   if (arg1) (arg1)->height = arg2;
44086 }
44087
44088
44089 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
44090   int jresult ;
44091   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44092   int result;
44093
44094   arg1 = (Dali::Rect< int > *)jarg1;
44095   result = (int) ((arg1)->height);
44096   jresult = result;
44097   return jresult;
44098 }
44099
44100
44101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
44102   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44103   int arg2 ;
44104
44105   arg1 = (Dali::Rect< int > *)jarg1;
44106   arg2 = (int)jarg2;
44107   if (arg1) (arg1)->top = arg2;
44108 }
44109
44110
44111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
44112   int jresult ;
44113   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44114   int result;
44115
44116   arg1 = (Dali::Rect< int > *)jarg1;
44117   result = (int) ((arg1)->top);
44118   jresult = result;
44119   return jresult;
44120 }
44121
44122
44123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
44124   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44125
44126   arg1 = (Dali::Rect< int > *)jarg1;
44127   {
44128     try {
44129       delete arg1;
44130     } catch (std::out_of_range& e) {
44131       {
44132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44133       };
44134     } catch (std::exception& e) {
44135       {
44136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44137       };
44138     } catch (...) {
44139       {
44140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44141       };
44142     }
44143   }
44144 }
44145
44146
44147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
44148   void * jresult ;
44149   Dali::Rect< float > *result = 0 ;
44150
44151   {
44152     try {
44153       result = (Dali::Rect< float > *)new Dali::Rect< float >();
44154     } catch (std::out_of_range& e) {
44155       {
44156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44157       };
44158     } catch (std::exception& e) {
44159       {
44160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44161       };
44162     } catch (...) {
44163       {
44164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44165       };
44166     }
44167   }
44168   jresult = (void *)result;
44169   return jresult;
44170 }
44171
44172
44173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
44174   void * jresult ;
44175   float arg1 ;
44176   float arg2 ;
44177   float arg3 ;
44178   float arg4 ;
44179   Dali::Rect< float > *result = 0 ;
44180
44181   arg1 = (float)jarg1;
44182   arg2 = (float)jarg2;
44183   arg3 = (float)jarg4;
44184   arg4 = (float)jarg3;
44185   {
44186     try {
44187       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
44188     } catch (std::out_of_range& e) {
44189       {
44190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44191       };
44192     } catch (std::exception& e) {
44193       {
44194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44195       };
44196     } catch (...) {
44197       {
44198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44199       };
44200     }
44201   }
44202   jresult = (void *)result;
44203   return jresult;
44204 }
44205
44206
44207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
44208   void * jresult ;
44209   Dali::Rect< float > *arg1 = 0 ;
44210   Dali::Rect< float > *result = 0 ;
44211
44212   arg1 = (Dali::Rect< float > *)jarg1;
44213   if (!arg1) {
44214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
44215     return 0;
44216   }
44217   {
44218     try {
44219       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
44220     } catch (std::out_of_range& e) {
44221       {
44222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44223       };
44224     } catch (std::exception& e) {
44225       {
44226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44227       };
44228     } catch (...) {
44229       {
44230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44231       };
44232     }
44233   }
44234   jresult = (void *)result;
44235   return jresult;
44236 }
44237
44238
44239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
44240   void * jresult ;
44241   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44242   Dali::Rect< float > *arg2 = 0 ;
44243   Dali::Rect< float > *result = 0 ;
44244
44245   arg1 = (Dali::Rect< float > *)jarg1;
44246   arg2 = (Dali::Rect< float > *)jarg2;
44247   if (!arg2) {
44248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
44249     return 0;
44250   }
44251   {
44252     try {
44253       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
44254     } catch (std::out_of_range& e) {
44255       {
44256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44257       };
44258     } catch (std::exception& e) {
44259       {
44260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44261       };
44262     } catch (...) {
44263       {
44264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44265       };
44266     }
44267   }
44268   jresult = (void *)result;
44269   return jresult;
44270 }
44271
44272
44273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
44274   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44275   float arg2 ;
44276   float arg3 ;
44277   float arg4 ;
44278   float arg5 ;
44279
44280   arg1 = (Dali::Rect< float > *)jarg1;
44281   arg2 = (float)jarg2;
44282   arg3 = (float)jarg3;
44283   arg4 = (float)jarg5;
44284   arg5 = (float)jarg4;
44285   {
44286     try {
44287       (arg1)->Set(arg2,arg3,arg4,arg5);
44288     } catch (std::out_of_range& e) {
44289       {
44290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44291       };
44292     } catch (std::exception& e) {
44293       {
44294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44295       };
44296     } catch (...) {
44297       {
44298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44299       };
44300     }
44301   }
44302 }
44303
44304
44305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
44306   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44307   float arg2 ;
44308
44309   arg1 = (Dali::Rect< float > *)jarg1;
44310   arg2 = (float)jarg2;
44311   if (arg1) (arg1)->left = arg2;
44312 }
44313
44314
44315 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
44316   float jresult ;
44317   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44318   float result;
44319
44320   arg1 = (Dali::Rect< float > *)jarg1;
44321   result = (float) ((arg1)->left);
44322   jresult = result;
44323   return jresult;
44324 }
44325
44326
44327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
44328   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44329   float arg2 ;
44330
44331   arg1 = (Dali::Rect< float > *)jarg1;
44332   arg2 = (float)jarg2;
44333   if (arg1) (arg1)->left = arg2;
44334 }
44335
44336
44337 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
44338   float jresult ;
44339   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44340   float result;
44341
44342   arg1 = (Dali::Rect< float > *)jarg1;
44343   result = (float) ((arg1)->left);
44344   jresult = result;
44345   return jresult;
44346 }
44347
44348
44349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
44350   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44351   float arg2 ;
44352
44353   arg1 = (Dali::Rect< float > *)jarg1;
44354   arg2 = (float)jarg2;
44355   if (arg1) (arg1)->right = arg2;
44356 }
44357
44358
44359 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
44360   float jresult ;
44361   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44362   float result;
44363
44364   arg1 = (Dali::Rect< float > *)jarg1;
44365   result = (float) ((arg1)->right);
44366   jresult = result;
44367   return jresult;
44368 }
44369
44370
44371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
44372   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44373   float arg2 ;
44374
44375   arg1 = (Dali::Rect< float > *)jarg1;
44376   arg2 = (float)jarg2;
44377   if (arg1) (arg1)->right = arg2;
44378 }
44379
44380
44381 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
44382   float jresult ;
44383   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44384   float result;
44385
44386   arg1 = (Dali::Rect< float > *)jarg1;
44387   result = (float) ((arg1)->right);
44388   jresult = result;
44389   return jresult;
44390 }
44391
44392
44393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
44394   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44395   float arg2 ;
44396
44397   arg1 = (Dali::Rect< float > *)jarg1;
44398   arg2 = (float)jarg2;
44399   if (arg1) (arg1)->bottom = arg2;
44400 }
44401
44402
44403 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
44404   float jresult ;
44405   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44406   float result;
44407
44408   arg1 = (Dali::Rect< float > *)jarg1;
44409   result = (float) ((arg1)->bottom);
44410   jresult = result;
44411   return jresult;
44412 }
44413
44414
44415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
44416   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44417   float arg2 ;
44418
44419   arg1 = (Dali::Rect< float > *)jarg1;
44420   arg2 = (float)jarg2;
44421   if (arg1) (arg1)->top = arg2;
44422 }
44423
44424
44425 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
44426   float jresult ;
44427   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44428   float result;
44429
44430   arg1 = (Dali::Rect< float > *)jarg1;
44431   result = (float) ((arg1)->top);
44432   jresult = result;
44433   return jresult;
44434 }
44435
44436
44437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
44438   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44439
44440   arg1 = (Dali::Rect< float > *)jarg1;
44441   {
44442     try {
44443       delete arg1;
44444     } catch (std::out_of_range& e) {
44445       {
44446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44447       };
44448     } catch (std::exception& e) {
44449       {
44450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44451       };
44452     } catch (...) {
44453       {
44454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44455       };
44456     }
44457   }
44458 }
44459
44460
44461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
44462   int jresult ;
44463   int result;
44464
44465   result = (int)Dali::Vector< int >::BaseType;
44466   jresult = (int)result;
44467   return jresult;
44468 }
44469
44470
44471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
44472   void * jresult ;
44473   Dali::Vector< int > *result = 0 ;
44474
44475   {
44476     try {
44477       result = (Dali::Vector< int > *)new Dali::Vector< int >();
44478     } catch (std::out_of_range& e) {
44479       {
44480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44481       };
44482     } catch (std::exception& e) {
44483       {
44484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44485       };
44486     } catch (...) {
44487       {
44488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44489       };
44490     }
44491   }
44492   jresult = (void *)result;
44493   return jresult;
44494 }
44495
44496
44497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
44498   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44499
44500   arg1 = (Dali::Vector< int > *)jarg1;
44501   {
44502     try {
44503       delete arg1;
44504     } catch (std::out_of_range& e) {
44505       {
44506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44507       };
44508     } catch (std::exception& e) {
44509       {
44510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44511       };
44512     } catch (...) {
44513       {
44514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44515       };
44516     }
44517   }
44518 }
44519
44520
44521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
44522   void * jresult ;
44523   Dali::Vector< int > *arg1 = 0 ;
44524   Dali::Vector< int > *result = 0 ;
44525
44526   arg1 = (Dali::Vector< int > *)jarg1;
44527   if (!arg1) {
44528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
44529     return 0;
44530   }
44531   {
44532     try {
44533       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
44534     } catch (std::out_of_range& e) {
44535       {
44536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44537       };
44538     } catch (std::exception& e) {
44539       {
44540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44541       };
44542     } catch (...) {
44543       {
44544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44545       };
44546     }
44547   }
44548   jresult = (void *)result;
44549   return jresult;
44550 }
44551
44552
44553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
44554   void * jresult ;
44555   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44556   Dali::Vector< int > *arg2 = 0 ;
44557   Dali::Vector< int > *result = 0 ;
44558
44559   arg1 = (Dali::Vector< int > *)jarg1;
44560   arg2 = (Dali::Vector< int > *)jarg2;
44561   if (!arg2) {
44562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
44563     return 0;
44564   }
44565   {
44566     try {
44567       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
44568     } catch (std::out_of_range& e) {
44569       {
44570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44571       };
44572     } catch (std::exception& e) {
44573       {
44574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44575       };
44576     } catch (...) {
44577       {
44578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44579       };
44580     }
44581   }
44582   jresult = (void *)result;
44583   return jresult;
44584 }
44585
44586
44587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
44588   void * jresult ;
44589   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44590   Dali::Vector< int >::Iterator result;
44591
44592   arg1 = (Dali::Vector< int > *)jarg1;
44593   {
44594     try {
44595       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
44596     } catch (std::out_of_range& e) {
44597       {
44598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44599       };
44600     } catch (std::exception& e) {
44601       {
44602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44603       };
44604     } catch (...) {
44605       {
44606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44607       };
44608     }
44609   }
44610   jresult = (void *)result;
44611   return jresult;
44612 }
44613
44614
44615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
44616   void * jresult ;
44617   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44618   Dali::Vector< int >::Iterator result;
44619
44620   arg1 = (Dali::Vector< int > *)jarg1;
44621   {
44622     try {
44623       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
44624     } catch (std::out_of_range& e) {
44625       {
44626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44627       };
44628     } catch (std::exception& e) {
44629       {
44630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44631       };
44632     } catch (...) {
44633       {
44634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44635       };
44636     }
44637   }
44638   jresult = (void *)result;
44639   return jresult;
44640 }
44641
44642
44643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
44644   void * jresult ;
44645   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44646   Dali::Vector< int >::SizeType arg2 ;
44647   Dali::Vector< int >::ItemType *result = 0 ;
44648
44649   arg1 = (Dali::Vector< int > *)jarg1;
44650   arg2 = (Dali::Vector< int >::SizeType)jarg2;
44651   {
44652     try {
44653       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
44654     } catch (std::out_of_range& e) {
44655       {
44656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44657       };
44658     } catch (std::exception& e) {
44659       {
44660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44661       };
44662     } catch (...) {
44663       {
44664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44665       };
44666     }
44667   }
44668   jresult = (void *)result;
44669   return jresult;
44670 }
44671
44672
44673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
44674   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44675   Dali::Vector< int >::ItemType *arg2 = 0 ;
44676   Dali::Vector< int >::ItemType temp2 ;
44677
44678   arg1 = (Dali::Vector< int > *)jarg1;
44679   temp2 = (Dali::Vector< int >::ItemType)jarg2;
44680   arg2 = &temp2;
44681   {
44682     try {
44683       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
44684     } catch (std::out_of_range& e) {
44685       {
44686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44687       };
44688     } catch (std::exception& e) {
44689       {
44690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44691       };
44692     } catch (...) {
44693       {
44694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44695       };
44696     }
44697   }
44698 }
44699
44700
44701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
44702   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44703   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
44704   Dali::Vector< int >::ItemType *arg3 = 0 ;
44705   Dali::Vector< int >::ItemType temp3 ;
44706
44707   arg1 = (Dali::Vector< int > *)jarg1;
44708   arg2 = (Dali::Vector< int >::Iterator)jarg2;
44709   temp3 = (Dali::Vector< int >::ItemType)jarg3;
44710   arg3 = &temp3;
44711   {
44712     try {
44713       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
44714     } catch (std::out_of_range& e) {
44715       {
44716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44717       };
44718     } catch (std::exception& e) {
44719       {
44720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44721       };
44722     } catch (...) {
44723       {
44724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44725       };
44726     }
44727   }
44728 }
44729
44730
44731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44732   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44733   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
44734   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
44735   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
44736
44737   arg1 = (Dali::Vector< int > *)jarg1;
44738   arg2 = (Dali::Vector< int >::Iterator)jarg2;
44739   arg3 = (Dali::Vector< int >::Iterator)jarg3;
44740   arg4 = (Dali::Vector< int >::Iterator)jarg4;
44741   {
44742     try {
44743       (arg1)->Insert(arg2,arg3,arg4);
44744     } catch (std::out_of_range& e) {
44745       {
44746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44747       };
44748     } catch (std::exception& e) {
44749       {
44750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44751       };
44752     } catch (...) {
44753       {
44754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44755       };
44756     }
44757   }
44758 }
44759
44760
44761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
44762   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44763   Dali::Vector< int >::SizeType arg2 ;
44764
44765   arg1 = (Dali::Vector< int > *)jarg1;
44766   arg2 = (Dali::Vector< int >::SizeType)jarg2;
44767   {
44768     try {
44769       (arg1)->Reserve(arg2);
44770     } catch (std::out_of_range& e) {
44771       {
44772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44773       };
44774     } catch (std::exception& e) {
44775       {
44776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44777       };
44778     } catch (...) {
44779       {
44780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44781       };
44782     }
44783   }
44784 }
44785
44786
44787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
44788   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44789   Dali::Vector< int >::SizeType arg2 ;
44790
44791   arg1 = (Dali::Vector< int > *)jarg1;
44792   arg2 = (Dali::Vector< int >::SizeType)jarg2;
44793   {
44794     try {
44795       (arg1)->Resize(arg2);
44796     } catch (std::out_of_range& e) {
44797       {
44798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44799       };
44800     } catch (std::exception& e) {
44801       {
44802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44803       };
44804     } catch (...) {
44805       {
44806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44807       };
44808     }
44809   }
44810 }
44811
44812
44813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
44814   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44815   Dali::Vector< int >::SizeType arg2 ;
44816   Dali::Vector< int >::ItemType *arg3 = 0 ;
44817   Dali::Vector< int >::ItemType temp3 ;
44818
44819   arg1 = (Dali::Vector< int > *)jarg1;
44820   arg2 = (Dali::Vector< int >::SizeType)jarg2;
44821   temp3 = (Dali::Vector< int >::ItemType)jarg3;
44822   arg3 = &temp3;
44823   {
44824     try {
44825       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
44826     } catch (std::out_of_range& e) {
44827       {
44828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44829       };
44830     } catch (std::exception& e) {
44831       {
44832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44833       };
44834     } catch (...) {
44835       {
44836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44837       };
44838     }
44839   }
44840 }
44841
44842
44843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
44844   void * jresult ;
44845   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44846   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
44847   Dali::Vector< int >::Iterator result;
44848
44849   arg1 = (Dali::Vector< int > *)jarg1;
44850   arg2 = (Dali::Vector< int >::Iterator)jarg2;
44851   {
44852     try {
44853       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
44854     } catch (std::out_of_range& e) {
44855       {
44856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44857       };
44858     } catch (std::exception& e) {
44859       {
44860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44861       };
44862     } catch (...) {
44863       {
44864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44865       };
44866     }
44867   }
44868   jresult = (void *)result;
44869   return jresult;
44870 }
44871
44872
44873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
44874   void * jresult ;
44875   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44876   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
44877   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
44878   Dali::Vector< int >::Iterator result;
44879
44880   arg1 = (Dali::Vector< int > *)jarg1;
44881   arg2 = (Dali::Vector< int >::Iterator)jarg2;
44882   arg3 = (Dali::Vector< int >::Iterator)jarg3;
44883   {
44884     try {
44885       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
44886     } catch (std::out_of_range& e) {
44887       {
44888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44889       };
44890     } catch (std::exception& e) {
44891       {
44892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44893       };
44894     } catch (...) {
44895       {
44896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44897       };
44898     }
44899   }
44900   jresult = (void *)result;
44901   return jresult;
44902 }
44903
44904
44905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
44906   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44907   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
44908
44909   arg1 = (Dali::Vector< int > *)jarg1;
44910   arg2 = (Dali::Vector< int >::Iterator)jarg2;
44911   {
44912     try {
44913       (arg1)->Remove(arg2);
44914     } catch (std::out_of_range& e) {
44915       {
44916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44917       };
44918     } catch (std::exception& e) {
44919       {
44920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44921       };
44922     } catch (...) {
44923       {
44924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44925       };
44926     }
44927   }
44928 }
44929
44930
44931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
44932   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44933   Dali::Vector< int > *arg2 = 0 ;
44934
44935   arg1 = (Dali::Vector< int > *)jarg1;
44936   arg2 = (Dali::Vector< int > *)jarg2;
44937   if (!arg2) {
44938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
44939     return ;
44940   }
44941   {
44942     try {
44943       (arg1)->Swap(*arg2);
44944     } catch (std::out_of_range& e) {
44945       {
44946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44947       };
44948     } catch (std::exception& e) {
44949       {
44950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44951       };
44952     } catch (...) {
44953       {
44954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44955       };
44956     }
44957   }
44958 }
44959
44960
44961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
44962   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44963
44964   arg1 = (Dali::Vector< int > *)jarg1;
44965   {
44966     try {
44967       (arg1)->Clear();
44968     } catch (std::out_of_range& e) {
44969       {
44970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44971       };
44972     } catch (std::exception& e) {
44973       {
44974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44975       };
44976     } catch (...) {
44977       {
44978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44979       };
44980     }
44981   }
44982 }
44983
44984
44985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
44986   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44987
44988   arg1 = (Dali::Vector< int > *)jarg1;
44989   {
44990     try {
44991       (arg1)->Release();
44992     } catch (std::out_of_range& e) {
44993       {
44994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44995       };
44996     } catch (std::exception& e) {
44997       {
44998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44999       };
45000     } catch (...) {
45001       {
45002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45003       };
45004     }
45005   }
45006 }
45007
45008
45009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
45010   int jresult ;
45011   int result;
45012
45013   result = (int)Dali::Vector< float >::BaseType;
45014   jresult = (int)result;
45015   return jresult;
45016 }
45017
45018
45019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
45020   void * jresult ;
45021   Dali::Vector< float > *result = 0 ;
45022
45023   {
45024     try {
45025       result = (Dali::Vector< float > *)new Dali::Vector< float >();
45026     } catch (std::out_of_range& e) {
45027       {
45028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45029       };
45030     } catch (std::exception& e) {
45031       {
45032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45033       };
45034     } catch (...) {
45035       {
45036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45037       };
45038     }
45039   }
45040   jresult = (void *)result;
45041   return jresult;
45042 }
45043
45044
45045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
45046   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45047
45048   arg1 = (Dali::Vector< float > *)jarg1;
45049   {
45050     try {
45051       delete arg1;
45052     } catch (std::out_of_range& e) {
45053       {
45054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45055       };
45056     } catch (std::exception& e) {
45057       {
45058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45059       };
45060     } catch (...) {
45061       {
45062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45063       };
45064     }
45065   }
45066 }
45067
45068
45069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
45070   void * jresult ;
45071   Dali::Vector< float > *arg1 = 0 ;
45072   Dali::Vector< float > *result = 0 ;
45073
45074   arg1 = (Dali::Vector< float > *)jarg1;
45075   if (!arg1) {
45076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
45077     return 0;
45078   }
45079   {
45080     try {
45081       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
45082     } catch (std::out_of_range& e) {
45083       {
45084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45085       };
45086     } catch (std::exception& e) {
45087       {
45088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45089       };
45090     } catch (...) {
45091       {
45092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45093       };
45094     }
45095   }
45096   jresult = (void *)result;
45097   return jresult;
45098 }
45099
45100
45101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
45102   void * jresult ;
45103   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45104   Dali::Vector< float > *arg2 = 0 ;
45105   Dali::Vector< float > *result = 0 ;
45106
45107   arg1 = (Dali::Vector< float > *)jarg1;
45108   arg2 = (Dali::Vector< float > *)jarg2;
45109   if (!arg2) {
45110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
45111     return 0;
45112   }
45113   {
45114     try {
45115       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
45116     } catch (std::out_of_range& e) {
45117       {
45118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45119       };
45120     } catch (std::exception& e) {
45121       {
45122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45123       };
45124     } catch (...) {
45125       {
45126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45127       };
45128     }
45129   }
45130   jresult = (void *)result;
45131   return jresult;
45132 }
45133
45134
45135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
45136   void * jresult ;
45137   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45138   Dali::Vector< float >::Iterator result;
45139
45140   arg1 = (Dali::Vector< float > *)jarg1;
45141   {
45142     try {
45143       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
45144     } catch (std::out_of_range& e) {
45145       {
45146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45147       };
45148     } catch (std::exception& e) {
45149       {
45150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45151       };
45152     } catch (...) {
45153       {
45154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45155       };
45156     }
45157   }
45158   jresult = (void *)result;
45159   return jresult;
45160 }
45161
45162
45163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
45164   void * jresult ;
45165   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45166   Dali::Vector< float >::Iterator result;
45167
45168   arg1 = (Dali::Vector< float > *)jarg1;
45169   {
45170     try {
45171       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
45172     } catch (std::out_of_range& e) {
45173       {
45174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45175       };
45176     } catch (std::exception& e) {
45177       {
45178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45179       };
45180     } catch (...) {
45181       {
45182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45183       };
45184     }
45185   }
45186   jresult = (void *)result;
45187   return jresult;
45188 }
45189
45190
45191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
45192   void * jresult ;
45193   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45194   Dali::Vector< float >::SizeType arg2 ;
45195   Dali::Vector< float >::ItemType *result = 0 ;
45196
45197   arg1 = (Dali::Vector< float > *)jarg1;
45198   arg2 = (Dali::Vector< float >::SizeType)jarg2;
45199   {
45200     try {
45201       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
45202     } catch (std::out_of_range& e) {
45203       {
45204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45205       };
45206     } catch (std::exception& e) {
45207       {
45208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45209       };
45210     } catch (...) {
45211       {
45212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45213       };
45214     }
45215   }
45216   jresult = (void *)result;
45217   return jresult;
45218 }
45219
45220
45221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
45222   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45223   Dali::Vector< float >::ItemType *arg2 = 0 ;
45224   Dali::Vector< float >::ItemType temp2 ;
45225
45226   arg1 = (Dali::Vector< float > *)jarg1;
45227   temp2 = (Dali::Vector< float >::ItemType)jarg2;
45228   arg2 = &temp2;
45229   {
45230     try {
45231       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
45232     } catch (std::out_of_range& e) {
45233       {
45234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45235       };
45236     } catch (std::exception& e) {
45237       {
45238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45239       };
45240     } catch (...) {
45241       {
45242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45243       };
45244     }
45245   }
45246 }
45247
45248
45249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
45250   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45251   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
45252   Dali::Vector< float >::ItemType *arg3 = 0 ;
45253   Dali::Vector< float >::ItemType temp3 ;
45254
45255   arg1 = (Dali::Vector< float > *)jarg1;
45256   arg2 = (Dali::Vector< float >::Iterator)jarg2;
45257   temp3 = (Dali::Vector< float >::ItemType)jarg3;
45258   arg3 = &temp3;
45259   {
45260     try {
45261       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
45262     } catch (std::out_of_range& e) {
45263       {
45264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45265       };
45266     } catch (std::exception& e) {
45267       {
45268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45269       };
45270     } catch (...) {
45271       {
45272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45273       };
45274     }
45275   }
45276 }
45277
45278
45279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
45280   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45281   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
45282   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
45283   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
45284
45285   arg1 = (Dali::Vector< float > *)jarg1;
45286   arg2 = (Dali::Vector< float >::Iterator)jarg2;
45287   arg3 = (Dali::Vector< float >::Iterator)jarg3;
45288   arg4 = (Dali::Vector< float >::Iterator)jarg4;
45289   {
45290     try {
45291       (arg1)->Insert(arg2,arg3,arg4);
45292     } catch (std::out_of_range& e) {
45293       {
45294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45295       };
45296     } catch (std::exception& e) {
45297       {
45298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45299       };
45300     } catch (...) {
45301       {
45302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45303       };
45304     }
45305   }
45306 }
45307
45308
45309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
45310   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45311   Dali::Vector< float >::SizeType arg2 ;
45312
45313   arg1 = (Dali::Vector< float > *)jarg1;
45314   arg2 = (Dali::Vector< float >::SizeType)jarg2;
45315   {
45316     try {
45317       (arg1)->Reserve(arg2);
45318     } catch (std::out_of_range& e) {
45319       {
45320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45321       };
45322     } catch (std::exception& e) {
45323       {
45324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45325       };
45326     } catch (...) {
45327       {
45328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45329       };
45330     }
45331   }
45332 }
45333
45334
45335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
45336   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45337   Dali::Vector< float >::SizeType arg2 ;
45338
45339   arg1 = (Dali::Vector< float > *)jarg1;
45340   arg2 = (Dali::Vector< float >::SizeType)jarg2;
45341   {
45342     try {
45343       (arg1)->Resize(arg2);
45344     } catch (std::out_of_range& e) {
45345       {
45346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45347       };
45348     } catch (std::exception& e) {
45349       {
45350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45351       };
45352     } catch (...) {
45353       {
45354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45355       };
45356     }
45357   }
45358 }
45359
45360
45361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
45362   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45363   Dali::Vector< float >::SizeType arg2 ;
45364   Dali::Vector< float >::ItemType *arg3 = 0 ;
45365   Dali::Vector< float >::ItemType temp3 ;
45366
45367   arg1 = (Dali::Vector< float > *)jarg1;
45368   arg2 = (Dali::Vector< float >::SizeType)jarg2;
45369   temp3 = (Dali::Vector< float >::ItemType)jarg3;
45370   arg3 = &temp3;
45371   {
45372     try {
45373       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
45374     } catch (std::out_of_range& e) {
45375       {
45376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45377       };
45378     } catch (std::exception& e) {
45379       {
45380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45381       };
45382     } catch (...) {
45383       {
45384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45385       };
45386     }
45387   }
45388 }
45389
45390
45391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
45392   void * jresult ;
45393   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45394   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
45395   Dali::Vector< float >::Iterator result;
45396
45397   arg1 = (Dali::Vector< float > *)jarg1;
45398   arg2 = (Dali::Vector< float >::Iterator)jarg2;
45399   {
45400     try {
45401       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
45402     } catch (std::out_of_range& e) {
45403       {
45404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45405       };
45406     } catch (std::exception& e) {
45407       {
45408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45409       };
45410     } catch (...) {
45411       {
45412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45413       };
45414     }
45415   }
45416   jresult = (void *)result;
45417   return jresult;
45418 }
45419
45420
45421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
45422   void * jresult ;
45423   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45424   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
45425   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
45426   Dali::Vector< float >::Iterator result;
45427
45428   arg1 = (Dali::Vector< float > *)jarg1;
45429   arg2 = (Dali::Vector< float >::Iterator)jarg2;
45430   arg3 = (Dali::Vector< float >::Iterator)jarg3;
45431   {
45432     try {
45433       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
45434     } catch (std::out_of_range& e) {
45435       {
45436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45437       };
45438     } catch (std::exception& e) {
45439       {
45440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45441       };
45442     } catch (...) {
45443       {
45444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45445       };
45446     }
45447   }
45448   jresult = (void *)result;
45449   return jresult;
45450 }
45451
45452
45453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
45454   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45455   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
45456
45457   arg1 = (Dali::Vector< float > *)jarg1;
45458   arg2 = (Dali::Vector< float >::Iterator)jarg2;
45459   {
45460     try {
45461       (arg1)->Remove(arg2);
45462     } catch (std::out_of_range& e) {
45463       {
45464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45465       };
45466     } catch (std::exception& e) {
45467       {
45468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45469       };
45470     } catch (...) {
45471       {
45472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45473       };
45474     }
45475   }
45476 }
45477
45478
45479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
45480   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45481   Dali::Vector< float > *arg2 = 0 ;
45482
45483   arg1 = (Dali::Vector< float > *)jarg1;
45484   arg2 = (Dali::Vector< float > *)jarg2;
45485   if (!arg2) {
45486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
45487     return ;
45488   }
45489   {
45490     try {
45491       (arg1)->Swap(*arg2);
45492     } catch (std::out_of_range& e) {
45493       {
45494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45495       };
45496     } catch (std::exception& e) {
45497       {
45498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45499       };
45500     } catch (...) {
45501       {
45502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45503       };
45504     }
45505   }
45506 }
45507
45508
45509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
45510   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45511
45512   arg1 = (Dali::Vector< float > *)jarg1;
45513   {
45514     try {
45515       (arg1)->Clear();
45516     } catch (std::out_of_range& e) {
45517       {
45518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45519       };
45520     } catch (std::exception& e) {
45521       {
45522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45523       };
45524     } catch (...) {
45525       {
45526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45527       };
45528     }
45529   }
45530 }
45531
45532
45533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
45534   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45535
45536   arg1 = (Dali::Vector< float > *)jarg1;
45537   {
45538     try {
45539       (arg1)->Release();
45540     } catch (std::out_of_range& e) {
45541       {
45542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45543       };
45544     } catch (std::exception& e) {
45545       {
45546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45547       };
45548     } catch (...) {
45549       {
45550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45551       };
45552     }
45553   }
45554 }
45555
45556
45557 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
45558   int jresult ;
45559   int result;
45560
45561   result = (int)Dali::Vector< unsigned char >::BaseType;
45562   jresult = (int)result;
45563   return jresult;
45564 }
45565
45566
45567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
45568   void * jresult ;
45569   Dali::Vector< unsigned char > *result = 0 ;
45570
45571   {
45572     try {
45573       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
45574     } catch (std::out_of_range& e) {
45575       {
45576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45577       };
45578     } catch (std::exception& e) {
45579       {
45580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45581       };
45582     } catch (...) {
45583       {
45584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45585       };
45586     }
45587   }
45588   jresult = (void *)result;
45589   return jresult;
45590 }
45591
45592
45593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
45594   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45595
45596   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45597   {
45598     try {
45599       delete arg1;
45600     } catch (std::out_of_range& e) {
45601       {
45602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45603       };
45604     } catch (std::exception& e) {
45605       {
45606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45607       };
45608     } catch (...) {
45609       {
45610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45611       };
45612     }
45613   }
45614 }
45615
45616
45617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
45618   void * jresult ;
45619   Dali::Vector< unsigned char > *arg1 = 0 ;
45620   Dali::Vector< unsigned char > *result = 0 ;
45621
45622   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45623   if (!arg1) {
45624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
45625     return 0;
45626   }
45627   {
45628     try {
45629       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
45630     } catch (std::out_of_range& e) {
45631       {
45632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45633       };
45634     } catch (std::exception& e) {
45635       {
45636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45637       };
45638     } catch (...) {
45639       {
45640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45641       };
45642     }
45643   }
45644   jresult = (void *)result;
45645   return jresult;
45646 }
45647
45648
45649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
45650   void * jresult ;
45651   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45652   Dali::Vector< unsigned char > *arg2 = 0 ;
45653   Dali::Vector< unsigned char > *result = 0 ;
45654
45655   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45656   arg2 = (Dali::Vector< unsigned char > *)jarg2;
45657   if (!arg2) {
45658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
45659     return 0;
45660   }
45661   {
45662     try {
45663       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
45664     } catch (std::out_of_range& e) {
45665       {
45666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45667       };
45668     } catch (std::exception& e) {
45669       {
45670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45671       };
45672     } catch (...) {
45673       {
45674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45675       };
45676     }
45677   }
45678   jresult = (void *)result;
45679   return jresult;
45680 }
45681
45682
45683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
45684   void * jresult ;
45685   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45686   Dali::Vector< unsigned char >::Iterator result;
45687
45688   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45689   {
45690     try {
45691       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
45692     } catch (std::out_of_range& e) {
45693       {
45694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45695       };
45696     } catch (std::exception& e) {
45697       {
45698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45699       };
45700     } catch (...) {
45701       {
45702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45703       };
45704     }
45705   }
45706   jresult = (void *)result;
45707   return jresult;
45708 }
45709
45710
45711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
45712   void * jresult ;
45713   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45714   Dali::Vector< unsigned char >::Iterator result;
45715
45716   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45717   {
45718     try {
45719       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
45720     } catch (std::out_of_range& e) {
45721       {
45722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45723       };
45724     } catch (std::exception& e) {
45725       {
45726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45727       };
45728     } catch (...) {
45729       {
45730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45731       };
45732     }
45733   }
45734   jresult = (void *)result;
45735   return jresult;
45736 }
45737
45738
45739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
45740   void * jresult ;
45741   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45742   Dali::Vector< unsigned char >::SizeType arg2 ;
45743   Dali::Vector< unsigned char >::ItemType *result = 0 ;
45744
45745   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45746   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
45747   {
45748     try {
45749       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
45750     } catch (std::out_of_range& e) {
45751       {
45752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45753       };
45754     } catch (std::exception& e) {
45755       {
45756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45757       };
45758     } catch (...) {
45759       {
45760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45761       };
45762     }
45763   }
45764   jresult = (void *)result;
45765   return jresult;
45766 }
45767
45768
45769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
45770   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45771   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
45772   Dali::Vector< unsigned char >::ItemType temp2 ;
45773
45774   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45775   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
45776   arg2 = &temp2;
45777   {
45778     try {
45779       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
45780     } catch (std::out_of_range& e) {
45781       {
45782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45783       };
45784     } catch (std::exception& e) {
45785       {
45786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45787       };
45788     } catch (...) {
45789       {
45790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45791       };
45792     }
45793   }
45794 }
45795
45796
45797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
45798   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45799   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
45800   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
45801   Dali::Vector< unsigned char >::ItemType temp3 ;
45802
45803   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45804   arg2 = jarg2;
45805   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
45806   arg3 = &temp3;
45807   {
45808     try {
45809       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
45810     } catch (std::out_of_range& e) {
45811       {
45812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45813       };
45814     } catch (std::exception& e) {
45815       {
45816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45817       };
45818     } catch (...) {
45819       {
45820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45821       };
45822     }
45823   }
45824
45825
45826 }
45827
45828
45829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
45830   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45831   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
45832   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
45833   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
45834
45835   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45836   arg2 = jarg2;
45837   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
45838   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
45839   {
45840     try {
45841       (arg1)->Insert(arg2,arg3,arg4);
45842     } catch (std::out_of_range& e) {
45843       {
45844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45845       };
45846     } catch (std::exception& e) {
45847       {
45848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45849       };
45850     } catch (...) {
45851       {
45852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45853       };
45854     }
45855   }
45856
45857
45858 }
45859
45860
45861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
45862   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45863   Dali::Vector< unsigned char >::SizeType arg2 ;
45864
45865   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45866   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
45867   {
45868     try {
45869       (arg1)->Reserve(arg2);
45870     } catch (std::out_of_range& e) {
45871       {
45872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45873       };
45874     } catch (std::exception& e) {
45875       {
45876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45877       };
45878     } catch (...) {
45879       {
45880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45881       };
45882     }
45883   }
45884 }
45885
45886
45887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
45888   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45889   Dali::Vector< unsigned char >::SizeType arg2 ;
45890
45891   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45892   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
45893   {
45894     try {
45895       (arg1)->Resize(arg2);
45896     } catch (std::out_of_range& e) {
45897       {
45898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45899       };
45900     } catch (std::exception& e) {
45901       {
45902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45903       };
45904     } catch (...) {
45905       {
45906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45907       };
45908     }
45909   }
45910 }
45911
45912
45913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
45914   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45915   Dali::Vector< unsigned char >::SizeType arg2 ;
45916   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
45917   Dali::Vector< unsigned char >::ItemType temp3 ;
45918
45919   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45920   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
45921   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
45922   arg3 = &temp3;
45923   {
45924     try {
45925       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
45926     } catch (std::out_of_range& e) {
45927       {
45928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45929       };
45930     } catch (std::exception& e) {
45931       {
45932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45933       };
45934     } catch (...) {
45935       {
45936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45937       };
45938     }
45939   }
45940 }
45941
45942
45943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
45944   void * jresult ;
45945   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45946   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
45947   Dali::Vector< unsigned char >::Iterator result;
45948
45949   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45950   arg2 = jarg2;
45951   {
45952     try {
45953       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
45954     } catch (std::out_of_range& e) {
45955       {
45956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45957       };
45958     } catch (std::exception& e) {
45959       {
45960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45961       };
45962     } catch (...) {
45963       {
45964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45965       };
45966     }
45967   }
45968   jresult = (void *)result;
45969
45970
45971   return jresult;
45972 }
45973
45974
45975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
45976   void * jresult ;
45977   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45978   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
45979   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
45980   Dali::Vector< unsigned char >::Iterator result;
45981
45982   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45983   arg2 = jarg2;
45984   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
45985   {
45986     try {
45987       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
45988     } catch (std::out_of_range& e) {
45989       {
45990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45991       };
45992     } catch (std::exception& e) {
45993       {
45994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45995       };
45996     } catch (...) {
45997       {
45998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45999       };
46000     }
46001   }
46002   jresult = (void *)result;
46003
46004
46005   return jresult;
46006 }
46007
46008
46009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
46010   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
46011   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
46012
46013   arg1 = (Dali::Vector< unsigned char > *)jarg1;
46014   arg2 = jarg2;
46015   {
46016     try {
46017       (arg1)->Remove(arg2);
46018     } catch (std::out_of_range& e) {
46019       {
46020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46021       };
46022     } catch (std::exception& e) {
46023       {
46024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46025       };
46026     } catch (...) {
46027       {
46028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46029       };
46030     }
46031   }
46032
46033
46034 }
46035
46036
46037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
46038   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
46039   Dali::Vector< unsigned char > *arg2 = 0 ;
46040
46041   arg1 = (Dali::Vector< unsigned char > *)jarg1;
46042   arg2 = (Dali::Vector< unsigned char > *)jarg2;
46043   if (!arg2) {
46044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
46045     return ;
46046   }
46047   {
46048     try {
46049       (arg1)->Swap(*arg2);
46050     } catch (std::out_of_range& e) {
46051       {
46052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46053       };
46054     } catch (std::exception& e) {
46055       {
46056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46057       };
46058     } catch (...) {
46059       {
46060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46061       };
46062     }
46063   }
46064 }
46065
46066
46067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
46068   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
46069
46070   arg1 = (Dali::Vector< unsigned char > *)jarg1;
46071   {
46072     try {
46073       (arg1)->Clear();
46074     } catch (std::out_of_range& e) {
46075       {
46076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46077       };
46078     } catch (std::exception& e) {
46079       {
46080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46081       };
46082     } catch (...) {
46083       {
46084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46085       };
46086     }
46087   }
46088 }
46089
46090
46091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
46092   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
46093
46094   arg1 = (Dali::Vector< unsigned char > *)jarg1;
46095   {
46096     try {
46097       (arg1)->Release();
46098     } catch (std::out_of_range& e) {
46099       {
46100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46101       };
46102     } catch (std::exception& e) {
46103       {
46104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46105       };
46106     } catch (...) {
46107       {
46108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46109       };
46110     }
46111   }
46112 }
46113
46114
46115 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
46116   int jresult ;
46117   int result;
46118
46119   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
46120   jresult = (int)result;
46121   return jresult;
46122 }
46123
46124
46125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
46126   void * jresult ;
46127   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
46128
46129   {
46130     try {
46131       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
46132     } catch (std::out_of_range& e) {
46133       {
46134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46135       };
46136     } catch (std::exception& e) {
46137       {
46138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46139       };
46140     } catch (...) {
46141       {
46142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46143       };
46144     }
46145   }
46146   jresult = (void *)result;
46147   return jresult;
46148 }
46149
46150
46151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
46152   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46153
46154   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46155   {
46156     try {
46157       delete arg1;
46158     } catch (std::out_of_range& e) {
46159       {
46160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46161       };
46162     } catch (std::exception& e) {
46163       {
46164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46165       };
46166     } catch (...) {
46167       {
46168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46169       };
46170     }
46171   }
46172 }
46173
46174
46175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
46176   void * jresult ;
46177   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
46178   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
46179
46180   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46181   if (!arg1) {
46182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
46183     return 0;
46184   }
46185   {
46186     try {
46187       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
46188     } catch (std::out_of_range& e) {
46189       {
46190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46191       };
46192     } catch (std::exception& e) {
46193       {
46194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46195       };
46196     } catch (...) {
46197       {
46198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46199       };
46200     }
46201   }
46202   jresult = (void *)result;
46203   return jresult;
46204 }
46205
46206
46207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
46208   void * jresult ;
46209   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46210   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
46211   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
46212
46213   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46214   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
46215   if (!arg2) {
46216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
46217     return 0;
46218   }
46219   {
46220     try {
46221       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
46222     } catch (std::out_of_range& e) {
46223       {
46224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46225       };
46226     } catch (std::exception& e) {
46227       {
46228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46229       };
46230     } catch (...) {
46231       {
46232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46233       };
46234     }
46235   }
46236   jresult = (void *)result;
46237   return jresult;
46238 }
46239
46240
46241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
46242   void * jresult ;
46243   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46244   Dali::Vector< Dali::Uint16Pair >::Iterator result;
46245
46246   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46247   {
46248     try {
46249       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
46250     } catch (std::out_of_range& e) {
46251       {
46252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46253       };
46254     } catch (std::exception& e) {
46255       {
46256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46257       };
46258     } catch (...) {
46259       {
46260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46261       };
46262     }
46263   }
46264   jresult = (void *)result;
46265   return jresult;
46266 }
46267
46268
46269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
46270   void * jresult ;
46271   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46272   Dali::Vector< Dali::Uint16Pair >::Iterator result;
46273
46274   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46275   {
46276     try {
46277       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
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_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
46298   void * jresult ;
46299   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46300   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
46301   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
46302
46303   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46304   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
46305   {
46306     try {
46307       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
46308     } catch (std::out_of_range& e) {
46309       {
46310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46311       };
46312     } catch (std::exception& e) {
46313       {
46314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46315       };
46316     } catch (...) {
46317       {
46318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46319       };
46320     }
46321   }
46322   jresult = (void *)result;
46323   return jresult;
46324 }
46325
46326
46327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
46328   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46329   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
46330
46331   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46332   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
46333   if (!arg2) {
46334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
46335     return ;
46336   }
46337   {
46338     try {
46339       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
46340     } catch (std::out_of_range& e) {
46341       {
46342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46343       };
46344     } catch (std::exception& e) {
46345       {
46346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46347       };
46348     } catch (...) {
46349       {
46350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46351       };
46352     }
46353   }
46354 }
46355
46356
46357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
46358   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46359   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46360   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
46361
46362   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46363   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
46364   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
46365   if (!arg3) {
46366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
46367     return ;
46368   }
46369   {
46370     try {
46371       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
46372     } catch (std::out_of_range& e) {
46373       {
46374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46375       };
46376     } catch (std::exception& e) {
46377       {
46378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46379       };
46380     } catch (...) {
46381       {
46382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46383       };
46384     }
46385   }
46386 }
46387
46388
46389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
46390   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46391   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46392   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46393   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46394
46395   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46396   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
46397   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
46398   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
46399   {
46400     try {
46401       (arg1)->Insert(arg2,arg3,arg4);
46402     } catch (std::out_of_range& e) {
46403       {
46404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46405       };
46406     } catch (std::exception& e) {
46407       {
46408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46409       };
46410     } catch (...) {
46411       {
46412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46413       };
46414     }
46415   }
46416 }
46417
46418
46419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
46420   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46421   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
46422
46423   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46424   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
46425   {
46426     try {
46427       (arg1)->Reserve(arg2);
46428     } catch (std::out_of_range& e) {
46429       {
46430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46431       };
46432     } catch (std::exception& e) {
46433       {
46434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46435       };
46436     } catch (...) {
46437       {
46438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46439       };
46440     }
46441   }
46442 }
46443
46444
46445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
46446   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46447   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
46448
46449   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46450   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
46451   {
46452     try {
46453       (arg1)->Resize(arg2);
46454     } catch (std::out_of_range& e) {
46455       {
46456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46457       };
46458     } catch (std::exception& e) {
46459       {
46460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46461       };
46462     } catch (...) {
46463       {
46464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46465       };
46466     }
46467   }
46468 }
46469
46470
46471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
46472   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46473   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
46474   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
46475
46476   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46477   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
46478   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
46479   if (!arg3) {
46480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
46481     return ;
46482   }
46483   {
46484     try {
46485       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
46486     } catch (std::out_of_range& e) {
46487       {
46488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46489       };
46490     } catch (std::exception& e) {
46491       {
46492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46493       };
46494     } catch (...) {
46495       {
46496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46497       };
46498     }
46499   }
46500 }
46501
46502
46503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
46504   void * jresult ;
46505   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46506   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46507   Dali::Vector< Dali::Uint16Pair >::Iterator result;
46508
46509   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46510   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
46511   {
46512     try {
46513       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
46514     } catch (std::out_of_range& e) {
46515       {
46516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46517       };
46518     } catch (std::exception& e) {
46519       {
46520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46521       };
46522     } catch (...) {
46523       {
46524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46525       };
46526     }
46527   }
46528   jresult = (void *)result;
46529   return jresult;
46530 }
46531
46532
46533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
46534   void * jresult ;
46535   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46536   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46537   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46538   Dali::Vector< Dali::Uint16Pair >::Iterator result;
46539
46540   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46541   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
46542   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
46543   {
46544     try {
46545       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
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_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
46566   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46567   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46568
46569   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46570   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
46571   {
46572     try {
46573       (arg1)->Remove(arg2);
46574     } catch (std::out_of_range& e) {
46575       {
46576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46577       };
46578     } catch (std::exception& e) {
46579       {
46580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46581       };
46582     } catch (...) {
46583       {
46584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46585       };
46586     }
46587   }
46588 }
46589
46590
46591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
46592   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46593   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
46594
46595   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46596   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
46597   if (!arg2) {
46598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
46599     return ;
46600   }
46601   {
46602     try {
46603       (arg1)->Swap(*arg2);
46604     } catch (std::out_of_range& e) {
46605       {
46606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46607       };
46608     } catch (std::exception& e) {
46609       {
46610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46611       };
46612     } catch (...) {
46613       {
46614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46615       };
46616     }
46617   }
46618 }
46619
46620
46621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
46622   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46623
46624   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46625   {
46626     try {
46627       (arg1)->Clear();
46628     } catch (std::out_of_range& e) {
46629       {
46630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46631       };
46632     } catch (std::exception& e) {
46633       {
46634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46635       };
46636     } catch (...) {
46637       {
46638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46639       };
46640     }
46641   }
46642 }
46643
46644
46645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
46646   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46647
46648   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46649   {
46650     try {
46651       (arg1)->Release();
46652     } catch (std::out_of_range& e) {
46653       {
46654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46655       };
46656     } catch (std::exception& e) {
46657       {
46658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46659       };
46660     } catch (...) {
46661       {
46662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46663       };
46664     }
46665   }
46666 }
46667
46668
46669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
46670   void * jresult ;
46671   Dali::Signal< void () > *result = 0 ;
46672
46673   {
46674     try {
46675       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
46676     } catch (std::out_of_range& e) {
46677       {
46678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46679       };
46680     } catch (std::exception& e) {
46681       {
46682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46683       };
46684     } catch (...) {
46685       {
46686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46687       };
46688     }
46689   }
46690   jresult = (void *)result;
46691   return jresult;
46692 }
46693
46694
46695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
46696   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46697
46698   arg1 = (Dali::Signal< void () > *)jarg1;
46699   {
46700     try {
46701       delete arg1;
46702     } catch (std::out_of_range& e) {
46703       {
46704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46705       };
46706     } catch (std::exception& e) {
46707       {
46708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46709       };
46710     } catch (...) {
46711       {
46712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46713       };
46714     }
46715   }
46716 }
46717
46718
46719 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
46720   unsigned int jresult ;
46721   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46722   bool result;
46723
46724   arg1 = (Dali::Signal< void () > *)jarg1;
46725   {
46726     try {
46727       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
46728     } catch (std::out_of_range& e) {
46729       {
46730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46731       };
46732     } catch (std::exception& e) {
46733       {
46734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46735       };
46736     } catch (...) {
46737       {
46738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46739       };
46740     }
46741   }
46742   jresult = result;
46743   return jresult;
46744 }
46745
46746
46747 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
46748   unsigned long jresult ;
46749   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46750   std::size_t result;
46751
46752   arg1 = (Dali::Signal< void () > *)jarg1;
46753   {
46754     try {
46755       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
46756     } catch (std::out_of_range& e) {
46757       {
46758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46759       };
46760     } catch (std::exception& e) {
46761       {
46762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46763       };
46764     } catch (...) {
46765       {
46766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46767       };
46768     }
46769   }
46770   jresult = (unsigned long)result;
46771   return jresult;
46772 }
46773
46774
46775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
46776   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46777   void (*arg2)() = (void (*)()) 0 ;
46778
46779   arg1 = (Dali::Signal< void () > *)jarg1;
46780   arg2 = (void (*)())jarg2;
46781   {
46782     try {
46783       (arg1)->Connect(arg2);
46784     } catch (std::out_of_range& e) {
46785       {
46786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46787       };
46788     } catch (std::exception& e) {
46789       {
46790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46791       };
46792     } catch (...) {
46793       {
46794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46795       };
46796     }
46797   }
46798 }
46799
46800
46801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
46802   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46803   void (*arg2)() = (void (*)()) 0 ;
46804
46805   arg1 = (Dali::Signal< void () > *)jarg1;
46806   arg2 = (void (*)())jarg2;
46807   {
46808     try {
46809       (arg1)->Disconnect(arg2);
46810     } catch (std::out_of_range& e) {
46811       {
46812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46813       };
46814     } catch (std::exception& e) {
46815       {
46816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46817       };
46818     } catch (...) {
46819       {
46820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46821       };
46822     }
46823   }
46824 }
46825
46826
46827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
46828   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46829   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
46830   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
46831
46832   arg1 = (Dali::Signal< void () > *)jarg1;
46833   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
46834   arg3 = (Dali::FunctorDelegate *)jarg3;
46835   {
46836     try {
46837       (arg1)->Connect(arg2,arg3);
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_VoidSignal_Emit(void * jarg1) {
46856   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46857
46858   arg1 = (Dali::Signal< void () > *)jarg1;
46859   {
46860     try {
46861       (arg1)->Emit();
46862     } catch (std::out_of_range& e) {
46863       {
46864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46865       };
46866     } catch (std::exception& e) {
46867       {
46868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46869       };
46870     } catch (...) {
46871       {
46872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46873       };
46874     }
46875   }
46876 }
46877
46878
46879 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
46880   unsigned int jresult ;
46881   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
46882   bool result;
46883
46884   arg1 = (Dali::Signal< void (float) > *)jarg1;
46885   {
46886     try {
46887       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
46888     } catch (std::out_of_range& e) {
46889       {
46890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46891       };
46892     } catch (std::exception& e) {
46893       {
46894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46895       };
46896     } catch (...) {
46897       {
46898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46899       };
46900     }
46901   }
46902   jresult = result;
46903   return jresult;
46904 }
46905
46906
46907 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
46908   unsigned long jresult ;
46909   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
46910   std::size_t result;
46911
46912   arg1 = (Dali::Signal< void (float) > *)jarg1;
46913   {
46914     try {
46915       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
46916     } catch (std::out_of_range& e) {
46917       {
46918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46919       };
46920     } catch (std::exception& e) {
46921       {
46922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46923       };
46924     } catch (...) {
46925       {
46926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46927       };
46928     }
46929   }
46930   jresult = (unsigned long)result;
46931   return jresult;
46932 }
46933
46934
46935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
46936   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
46937   void (*arg2)(float) = (void (*)(float)) 0 ;
46938
46939   arg1 = (Dali::Signal< void (float) > *)jarg1;
46940   arg2 = (void (*)(float))jarg2;
46941   {
46942     try {
46943       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
46944     } catch (std::out_of_range& e) {
46945       {
46946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46947       };
46948     } catch (std::exception& e) {
46949       {
46950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46951       };
46952     } catch (...) {
46953       {
46954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46955       };
46956     }
46957   }
46958 }
46959
46960
46961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
46962   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
46963   void (*arg2)(float) = (void (*)(float)) 0 ;
46964
46965   arg1 = (Dali::Signal< void (float) > *)jarg1;
46966   arg2 = (void (*)(float))jarg2;
46967   {
46968     try {
46969       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
46970     } catch (std::out_of_range& e) {
46971       {
46972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46973       };
46974     } catch (std::exception& e) {
46975       {
46976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46977       };
46978     } catch (...) {
46979       {
46980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46981       };
46982     }
46983   }
46984 }
46985
46986
46987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
46988   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
46989   float arg2 ;
46990
46991   arg1 = (Dali::Signal< void (float) > *)jarg1;
46992   arg2 = (float)jarg2;
46993   {
46994     try {
46995       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
46996     } catch (std::out_of_range& e) {
46997       {
46998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46999       };
47000     } catch (std::exception& e) {
47001       {
47002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47003       };
47004     } catch (...) {
47005       {
47006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47007       };
47008     }
47009   }
47010 }
47011
47012
47013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
47014   void * jresult ;
47015   Dali::Signal< void (float) > *result = 0 ;
47016
47017   {
47018     try {
47019       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
47020     } catch (std::out_of_range& e) {
47021       {
47022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47023       };
47024     } catch (std::exception& e) {
47025       {
47026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47027       };
47028     } catch (...) {
47029       {
47030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47031       };
47032     }
47033   }
47034   jresult = (void *)result;
47035   return jresult;
47036 }
47037
47038
47039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
47040   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
47041
47042   arg1 = (Dali::Signal< void (float) > *)jarg1;
47043   {
47044     try {
47045       delete arg1;
47046     } catch (std::out_of_range& e) {
47047       {
47048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47049       };
47050     } catch (std::exception& e) {
47051       {
47052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47053       };
47054     } catch (...) {
47055       {
47056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47057       };
47058     }
47059   }
47060 }
47061
47062
47063 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
47064   unsigned int jresult ;
47065   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
47066   bool result;
47067
47068   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
47069   {
47070     try {
47071       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
47072     } catch (std::out_of_range& e) {
47073       {
47074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47075       };
47076     } catch (std::exception& e) {
47077       {
47078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47079       };
47080     } catch (...) {
47081       {
47082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47083       };
47084     }
47085   }
47086   jresult = result;
47087   return jresult;
47088 }
47089
47090
47091 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
47092   unsigned long jresult ;
47093   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
47094   std::size_t result;
47095
47096   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
47097   {
47098     try {
47099       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
47100     } catch (std::out_of_range& e) {
47101       {
47102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47103       };
47104     } catch (std::exception& e) {
47105       {
47106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47107       };
47108     } catch (...) {
47109       {
47110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47111       };
47112     }
47113   }
47114   jresult = (unsigned long)result;
47115   return jresult;
47116 }
47117
47118
47119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
47120   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
47121   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
47122
47123   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
47124   arg2 = (void (*)(Dali::BaseHandle))jarg2;
47125   {
47126     try {
47127       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
47128     } catch (std::out_of_range& e) {
47129       {
47130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47131       };
47132     } catch (std::exception& e) {
47133       {
47134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47135       };
47136     } catch (...) {
47137       {
47138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47139       };
47140     }
47141   }
47142 }
47143
47144
47145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
47146   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
47147   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
47148
47149   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
47150   arg2 = (void (*)(Dali::BaseHandle))jarg2;
47151   {
47152     try {
47153       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
47154     } catch (std::out_of_range& e) {
47155       {
47156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47157       };
47158     } catch (std::exception& e) {
47159       {
47160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47161       };
47162     } catch (...) {
47163       {
47164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47165       };
47166     }
47167   }
47168 }
47169
47170
47171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
47172   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
47173   Dali::BaseHandle arg2 ;
47174   Dali::BaseHandle *argp2 ;
47175
47176   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
47177   argp2 = (Dali::BaseHandle *)jarg2;
47178   if (!argp2) {
47179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47180     return ;
47181   }
47182   arg2 = *argp2;
47183   {
47184     try {
47185       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
47186     } catch (std::out_of_range& e) {
47187       {
47188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47189       };
47190     } catch (std::exception& e) {
47191       {
47192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47193       };
47194     } catch (...) {
47195       {
47196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47197       };
47198     }
47199   }
47200 }
47201
47202
47203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
47204   void * jresult ;
47205   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
47206
47207   {
47208     try {
47209       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
47210     } catch (std::out_of_range& e) {
47211       {
47212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47213       };
47214     } catch (std::exception& e) {
47215       {
47216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47217       };
47218     } catch (...) {
47219       {
47220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47221       };
47222     }
47223   }
47224   jresult = (void *)result;
47225   return jresult;
47226 }
47227
47228
47229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
47230   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
47231
47232   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
47233   {
47234     try {
47235       delete arg1;
47236     } catch (std::out_of_range& e) {
47237       {
47238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47239       };
47240     } catch (std::exception& e) {
47241       {
47242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47243       };
47244     } catch (...) {
47245       {
47246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47247       };
47248     }
47249   }
47250 }
47251
47252
47253 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
47254   unsigned int jresult ;
47255   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
47256   bool result;
47257
47258   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
47259   {
47260     try {
47261       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
47262     } catch (std::out_of_range& e) {
47263       {
47264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47265       };
47266     } catch (std::exception& e) {
47267       {
47268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47269       };
47270     } catch (...) {
47271       {
47272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47273       };
47274     }
47275   }
47276   jresult = result;
47277   return jresult;
47278 }
47279
47280
47281 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
47282   unsigned long jresult ;
47283   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
47284   std::size_t result;
47285
47286   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
47287   {
47288     try {
47289       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
47290     } catch (std::out_of_range& e) {
47291       {
47292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47293       };
47294     } catch (std::exception& e) {
47295       {
47296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47297       };
47298     } catch (...) {
47299       {
47300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47301       };
47302     }
47303   }
47304   jresult = (unsigned long)result;
47305   return jresult;
47306 }
47307
47308
47309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
47310   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
47311   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
47312
47313   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
47314   arg2 = (void (*)(Dali::RefObject const *))jarg2;
47315   {
47316     try {
47317       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
47318     } catch (std::out_of_range& e) {
47319       {
47320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47321       };
47322     } catch (std::exception& e) {
47323       {
47324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47325       };
47326     } catch (...) {
47327       {
47328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47329       };
47330     }
47331   }
47332 }
47333
47334
47335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
47336   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
47337   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
47338
47339   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
47340   arg2 = (void (*)(Dali::RefObject const *))jarg2;
47341   {
47342     try {
47343       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
47344     } catch (std::out_of_range& e) {
47345       {
47346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47347       };
47348     } catch (std::exception& e) {
47349       {
47350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47351       };
47352     } catch (...) {
47353       {
47354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47355       };
47356     }
47357   }
47358 }
47359
47360
47361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
47362   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
47363   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
47364
47365   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
47366   arg2 = (Dali::RefObject *)jarg2;
47367   {
47368     try {
47369       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
47370     } catch (std::out_of_range& e) {
47371       {
47372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47373       };
47374     } catch (std::exception& e) {
47375       {
47376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47377       };
47378     } catch (...) {
47379       {
47380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47381       };
47382     }
47383   }
47384 }
47385
47386
47387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
47388   void * jresult ;
47389   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
47390
47391   {
47392     try {
47393       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
47394     } catch (std::out_of_range& e) {
47395       {
47396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47397       };
47398     } catch (std::exception& e) {
47399       {
47400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47401       };
47402     } catch (...) {
47403       {
47404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47405       };
47406     }
47407   }
47408   jresult = (void *)result;
47409   return jresult;
47410 }
47411
47412
47413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
47414   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
47415
47416   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
47417   {
47418     try {
47419       delete arg1;
47420     } catch (std::out_of_range& e) {
47421       {
47422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47423       };
47424     } catch (std::exception& e) {
47425       {
47426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47427       };
47428     } catch (...) {
47429       {
47430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47431       };
47432     }
47433   }
47434 }
47435
47436
47437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
47438   unsigned int jresult ;
47439   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
47440   bool result;
47441
47442   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
47443   {
47444     try {
47445       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
47446     } catch (std::out_of_range& e) {
47447       {
47448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47449       };
47450     } catch (std::exception& e) {
47451       {
47452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47453       };
47454     } catch (...) {
47455       {
47456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47457       };
47458     }
47459   }
47460   jresult = result;
47461   return jresult;
47462 }
47463
47464
47465 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
47466   unsigned long jresult ;
47467   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
47468   std::size_t result;
47469
47470   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
47471   {
47472     try {
47473       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
47474     } catch (std::out_of_range& e) {
47475       {
47476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47477       };
47478     } catch (std::exception& e) {
47479       {
47480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47481       };
47482     } catch (...) {
47483       {
47484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47485       };
47486     }
47487   }
47488   jresult = (unsigned long)result;
47489   return jresult;
47490 }
47491
47492
47493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
47494   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
47495   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
47496
47497   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
47498   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
47499   {
47500     try {
47501       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
47502     } catch (std::out_of_range& e) {
47503       {
47504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47505       };
47506     } catch (std::exception& e) {
47507       {
47508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47509       };
47510     } catch (...) {
47511       {
47512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47513       };
47514     }
47515   }
47516 }
47517
47518
47519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
47520   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
47521   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
47522
47523   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
47524   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
47525   {
47526     try {
47527       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
47528     } catch (std::out_of_range& e) {
47529       {
47530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47531       };
47532     } catch (std::exception& e) {
47533       {
47534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47535       };
47536     } catch (...) {
47537       {
47538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47539       };
47540     }
47541   }
47542 }
47543
47544
47545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
47546   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
47547   Dali::PropertyNotification *arg2 = 0 ;
47548
47549   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
47550   arg2 = (Dali::PropertyNotification *)jarg2;
47551   if (!arg2) {
47552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
47553     return ;
47554   }
47555   {
47556     try {
47557       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
47558     } catch (std::out_of_range& e) {
47559       {
47560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47561       };
47562     } catch (std::exception& e) {
47563       {
47564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47565       };
47566     } catch (...) {
47567       {
47568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47569       };
47570     }
47571   }
47572 }
47573
47574
47575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
47576   void * jresult ;
47577   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
47578
47579   {
47580     try {
47581       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
47582     } catch (std::out_of_range& e) {
47583       {
47584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47585       };
47586     } catch (std::exception& e) {
47587       {
47588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47589       };
47590     } catch (...) {
47591       {
47592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47593       };
47594     }
47595   }
47596   jresult = (void *)result;
47597   return jresult;
47598 }
47599
47600
47601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
47602   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
47603
47604   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
47605   {
47606     try {
47607       delete arg1;
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 unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
47626   unsigned int jresult ;
47627   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
47628   bool result;
47629
47630   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
47631   {
47632     try {
47633       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
47634     } catch (std::out_of_range& e) {
47635       {
47636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47637       };
47638     } catch (std::exception& e) {
47639       {
47640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47641       };
47642     } catch (...) {
47643       {
47644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47645       };
47646     }
47647   }
47648   jresult = result;
47649   return jresult;
47650 }
47651
47652
47653 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
47654   unsigned long jresult ;
47655   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
47656   std::size_t result;
47657
47658   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
47659   {
47660     try {
47661       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
47662     } catch (std::out_of_range& e) {
47663       {
47664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47665       };
47666     } catch (std::exception& e) {
47667       {
47668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47669       };
47670     } catch (...) {
47671       {
47672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47673       };
47674     }
47675   }
47676   jresult = (unsigned long)result;
47677   return jresult;
47678 }
47679
47680
47681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
47682   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
47683   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
47684
47685   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
47686   arg2 = (void (*)(Dali::Image))jarg2;
47687   {
47688     try {
47689       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
47690     } catch (std::out_of_range& e) {
47691       {
47692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47693       };
47694     } catch (std::exception& e) {
47695       {
47696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47697       };
47698     } catch (...) {
47699       {
47700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47701       };
47702     }
47703   }
47704 }
47705
47706
47707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
47708   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
47709   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
47710
47711   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
47712   arg2 = (void (*)(Dali::Image))jarg2;
47713   {
47714     try {
47715       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
47716     } catch (std::out_of_range& e) {
47717       {
47718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47719       };
47720     } catch (std::exception& e) {
47721       {
47722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47723       };
47724     } catch (...) {
47725       {
47726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47727       };
47728     }
47729   }
47730 }
47731
47732
47733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
47734   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
47735   Dali::Image arg2 ;
47736   Dali::Image *argp2 ;
47737
47738   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
47739   argp2 = (Dali::Image *)jarg2;
47740   if (!argp2) {
47741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
47742     return ;
47743   }
47744   arg2 = *argp2;
47745   {
47746     try {
47747       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
47748     } catch (std::out_of_range& e) {
47749       {
47750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47751       };
47752     } catch (std::exception& e) {
47753       {
47754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47755       };
47756     } catch (...) {
47757       {
47758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47759       };
47760     }
47761   }
47762 }
47763
47764
47765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
47766   void * jresult ;
47767   Dali::Signal< void (Dali::Image) > *result = 0 ;
47768
47769   {
47770     try {
47771       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
47772     } catch (std::out_of_range& e) {
47773       {
47774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47775       };
47776     } catch (std::exception& e) {
47777       {
47778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47779       };
47780     } catch (...) {
47781       {
47782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47783       };
47784     }
47785   }
47786   jresult = (void *)result;
47787   return jresult;
47788 }
47789
47790
47791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
47792   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
47793
47794   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
47795   {
47796     try {
47797       delete arg1;
47798     } catch (std::out_of_range& e) {
47799       {
47800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47801       };
47802     } catch (std::exception& e) {
47803       {
47804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47805       };
47806     } catch (...) {
47807       {
47808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47809       };
47810     }
47811   }
47812 }
47813
47814
47815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
47816   void * jresult ;
47817   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
47818
47819   {
47820     try {
47821       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
47822     } catch (std::out_of_range& e) {
47823       {
47824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47825       };
47826     } catch (std::exception& e) {
47827       {
47828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47829       };
47830     } catch (...) {
47831       {
47832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47833       };
47834     }
47835   }
47836   jresult = (void *)result;
47837   return jresult;
47838 }
47839
47840
47841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
47842   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
47843
47844   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
47845   {
47846     try {
47847       delete arg1;
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 unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
47866   unsigned int jresult ;
47867   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
47868   bool result;
47869
47870   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
47871   {
47872     try {
47873       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);
47874     } catch (std::out_of_range& e) {
47875       {
47876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47877       };
47878     } catch (std::exception& e) {
47879       {
47880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47881       };
47882     } catch (...) {
47883       {
47884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47885       };
47886     }
47887   }
47888   jresult = result;
47889   return jresult;
47890 }
47891
47892
47893 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
47894   unsigned long jresult ;
47895   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
47896   std::size_t result;
47897
47898   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
47899   {
47900     try {
47901       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);
47902     } catch (std::out_of_range& e) {
47903       {
47904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47905       };
47906     } catch (std::exception& e) {
47907       {
47908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47909       };
47910     } catch (...) {
47911       {
47912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47913       };
47914     }
47915   }
47916   jresult = (unsigned long)result;
47917   return jresult;
47918 }
47919
47920
47921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
47922   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
47923   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
47924
47925   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
47926   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
47927   {
47928     try {
47929       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
47930     } catch (std::out_of_range& e) {
47931       {
47932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47933       };
47934     } catch (std::exception& e) {
47935       {
47936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47937       };
47938     } catch (...) {
47939       {
47940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47941       };
47942     }
47943   }
47944 }
47945
47946
47947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
47948   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
47949   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
47950
47951   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
47952   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
47953   {
47954     try {
47955       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
47956     } catch (std::out_of_range& e) {
47957       {
47958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47959       };
47960     } catch (std::exception& e) {
47961       {
47962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47963       };
47964     } catch (...) {
47965       {
47966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47967       };
47968     }
47969   }
47970 }
47971
47972
47973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
47974   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
47975   Dali::Actor arg2 ;
47976   Dali::LongPressGesture *arg3 = 0 ;
47977   Dali::Actor *argp2 ;
47978
47979   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
47980   argp2 = (Dali::Actor *)jarg2;
47981   if (!argp2) {
47982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47983     return ;
47984   }
47985   arg2 = *argp2;
47986   arg3 = (Dali::LongPressGesture *)jarg3;
47987   if (!arg3) {
47988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
47989     return ;
47990   }
47991   {
47992     try {
47993       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture 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_new_LongPressGestureDetectedSignal() {
48012   void * jresult ;
48013   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
48014
48015   {
48016     try {
48017       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
48018     } catch (std::out_of_range& e) {
48019       {
48020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48021       };
48022     } catch (std::exception& e) {
48023       {
48024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48025       };
48026     } catch (...) {
48027       {
48028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48029       };
48030     }
48031   }
48032   jresult = (void *)result;
48033   return jresult;
48034 }
48035
48036
48037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
48038   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
48039
48040   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
48041   {
48042     try {
48043       delete arg1;
48044     } catch (std::out_of_range& e) {
48045       {
48046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48047       };
48048     } catch (std::exception& e) {
48049       {
48050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48051       };
48052     } catch (...) {
48053       {
48054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48055       };
48056     }
48057   }
48058 }
48059
48060
48061 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
48062   unsigned int jresult ;
48063   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
48064   bool result;
48065
48066   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
48067   {
48068     try {
48069       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);
48070     } catch (std::out_of_range& e) {
48071       {
48072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48073       };
48074     } catch (std::exception& e) {
48075       {
48076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48077       };
48078     } catch (...) {
48079       {
48080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48081       };
48082     }
48083   }
48084   jresult = result;
48085   return jresult;
48086 }
48087
48088
48089 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
48090   unsigned long jresult ;
48091   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
48092   std::size_t result;
48093
48094   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
48095   {
48096     try {
48097       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);
48098     } catch (std::out_of_range& e) {
48099       {
48100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48101       };
48102     } catch (std::exception& e) {
48103       {
48104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48105       };
48106     } catch (...) {
48107       {
48108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48109       };
48110     }
48111   }
48112   jresult = (unsigned long)result;
48113   return jresult;
48114 }
48115
48116
48117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
48118   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
48119   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
48120
48121   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
48122   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
48123   {
48124     try {
48125       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
48126     } catch (std::out_of_range& e) {
48127       {
48128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48129       };
48130     } catch (std::exception& e) {
48131       {
48132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48133       };
48134     } catch (...) {
48135       {
48136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48137       };
48138     }
48139   }
48140 }
48141
48142
48143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
48144   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
48145   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
48146
48147   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
48148   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
48149   {
48150     try {
48151       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
48152     } catch (std::out_of_range& e) {
48153       {
48154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48155       };
48156     } catch (std::exception& e) {
48157       {
48158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48159       };
48160     } catch (...) {
48161       {
48162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48163       };
48164     }
48165   }
48166 }
48167
48168
48169 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
48170   unsigned int jresult ;
48171   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
48172   Dali::Actor arg2 ;
48173   Dali::TouchData *arg3 = 0 ;
48174   Dali::Actor *argp2 ;
48175   bool result;
48176
48177   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
48178   argp2 = (Dali::Actor *)jarg2;
48179   if (!argp2) {
48180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48181     return 0;
48182   }
48183   arg2 = *argp2;
48184   arg3 = (Dali::TouchData *)jarg3;
48185   if (!arg3) {
48186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
48187     return 0;
48188   }
48189   {
48190     try {
48191       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
48192     } catch (std::out_of_range& e) {
48193       {
48194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48195       };
48196     } catch (std::exception& e) {
48197       {
48198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48199       };
48200     } catch (...) {
48201       {
48202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48203       };
48204     }
48205   }
48206   jresult = result;
48207   return jresult;
48208 }
48209
48210
48211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
48212   void * jresult ;
48213   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
48214
48215   {
48216     try {
48217       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
48218     } catch (std::out_of_range& e) {
48219       {
48220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48221       };
48222     } catch (std::exception& e) {
48223       {
48224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48225       };
48226     } catch (...) {
48227       {
48228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48229       };
48230     }
48231   }
48232   jresult = (void *)result;
48233   return jresult;
48234 }
48235
48236
48237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
48238   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
48239
48240   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
48241   {
48242     try {
48243       delete arg1;
48244     } catch (std::out_of_range& e) {
48245       {
48246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48247       };
48248     } catch (std::exception& e) {
48249       {
48250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48251       };
48252     } catch (...) {
48253       {
48254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48255       };
48256     }
48257   }
48258 }
48259
48260
48261 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
48262   unsigned int jresult ;
48263   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
48264   bool result;
48265
48266   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
48267   {
48268     try {
48269       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);
48270     } catch (std::out_of_range& e) {
48271       {
48272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48273       };
48274     } catch (std::exception& e) {
48275       {
48276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48277       };
48278     } catch (...) {
48279       {
48280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48281       };
48282     }
48283   }
48284   jresult = result;
48285   return jresult;
48286 }
48287
48288
48289 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
48290   unsigned long jresult ;
48291   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
48292   std::size_t result;
48293
48294   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
48295   {
48296     try {
48297       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);
48298     } catch (std::out_of_range& e) {
48299       {
48300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48301       };
48302     } catch (std::exception& e) {
48303       {
48304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48305       };
48306     } catch (...) {
48307       {
48308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48309       };
48310     }
48311   }
48312   jresult = (unsigned long)result;
48313   return jresult;
48314 }
48315
48316
48317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
48318   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
48319   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
48320
48321   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
48322   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
48323   {
48324     try {
48325       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
48326     } catch (std::out_of_range& e) {
48327       {
48328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48329       };
48330     } catch (std::exception& e) {
48331       {
48332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48333       };
48334     } catch (...) {
48335       {
48336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48337       };
48338     }
48339   }
48340 }
48341
48342
48343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
48344   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
48345   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
48346
48347   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
48348   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
48349   {
48350     try {
48351       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
48352     } catch (std::out_of_range& e) {
48353       {
48354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48355       };
48356     } catch (std::exception& e) {
48357       {
48358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48359       };
48360     } catch (...) {
48361       {
48362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48363       };
48364     }
48365   }
48366 }
48367
48368
48369 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
48370   unsigned int jresult ;
48371   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
48372   Dali::Actor arg2 ;
48373   Dali::HoverEvent *arg3 = 0 ;
48374   Dali::Actor *argp2 ;
48375   bool result;
48376
48377   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
48378   argp2 = (Dali::Actor *)jarg2;
48379   if (!argp2) {
48380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48381     return 0;
48382   }
48383   arg2 = *argp2;
48384   arg3 = (Dali::HoverEvent *)jarg3;
48385   if (!arg3) {
48386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
48387     return 0;
48388   }
48389   {
48390     try {
48391       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
48392     } catch (std::out_of_range& e) {
48393       {
48394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48395       };
48396     } catch (std::exception& e) {
48397       {
48398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48399       };
48400     } catch (...) {
48401       {
48402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48403       };
48404     }
48405   }
48406   jresult = result;
48407   return jresult;
48408 }
48409
48410
48411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
48412   void * jresult ;
48413   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
48414
48415   {
48416     try {
48417       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
48418     } catch (std::out_of_range& e) {
48419       {
48420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48421       };
48422     } catch (std::exception& e) {
48423       {
48424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48425       };
48426     } catch (...) {
48427       {
48428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48429       };
48430     }
48431   }
48432   jresult = (void *)result;
48433   return jresult;
48434 }
48435
48436
48437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
48438   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
48439
48440   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
48441   {
48442     try {
48443       delete arg1;
48444     } catch (std::out_of_range& e) {
48445       {
48446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48447       };
48448     } catch (std::exception& e) {
48449       {
48450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48451       };
48452     } catch (...) {
48453       {
48454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48455       };
48456     }
48457   }
48458 }
48459
48460
48461 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
48462   unsigned int jresult ;
48463   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
48464   bool result;
48465
48466   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
48467   {
48468     try {
48469       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);
48470     } catch (std::out_of_range& e) {
48471       {
48472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48473       };
48474     } catch (std::exception& e) {
48475       {
48476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48477       };
48478     } catch (...) {
48479       {
48480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48481       };
48482     }
48483   }
48484   jresult = result;
48485   return jresult;
48486 }
48487
48488
48489 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
48490   unsigned long jresult ;
48491   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
48492   std::size_t result;
48493
48494   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
48495   {
48496     try {
48497       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);
48498     } catch (std::out_of_range& e) {
48499       {
48500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48501       };
48502     } catch (std::exception& e) {
48503       {
48504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48505       };
48506     } catch (...) {
48507       {
48508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48509       };
48510     }
48511   }
48512   jresult = (unsigned long)result;
48513   return jresult;
48514 }
48515
48516
48517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
48518   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
48519   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
48520
48521   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
48522   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
48523   {
48524     try {
48525       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
48526     } catch (std::out_of_range& e) {
48527       {
48528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48529       };
48530     } catch (std::exception& e) {
48531       {
48532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48533       };
48534     } catch (...) {
48535       {
48536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48537       };
48538     }
48539   }
48540 }
48541
48542
48543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
48544   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
48545   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
48546
48547   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
48548   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
48549   {
48550     try {
48551       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
48552     } catch (std::out_of_range& e) {
48553       {
48554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48555       };
48556     } catch (std::exception& e) {
48557       {
48558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48559       };
48560     } catch (...) {
48561       {
48562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48563       };
48564     }
48565   }
48566 }
48567
48568
48569 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
48570   unsigned int jresult ;
48571   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
48572   Dali::Actor arg2 ;
48573   Dali::WheelEvent *arg3 = 0 ;
48574   Dali::Actor *argp2 ;
48575   bool result;
48576
48577   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
48578   argp2 = (Dali::Actor *)jarg2;
48579   if (!argp2) {
48580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48581     return 0;
48582   }
48583   arg2 = *argp2;
48584   arg3 = (Dali::WheelEvent *)jarg3;
48585   if (!arg3) {
48586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
48587     return 0;
48588   }
48589   {
48590     try {
48591       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
48592     } catch (std::out_of_range& e) {
48593       {
48594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48595       };
48596     } catch (std::exception& e) {
48597       {
48598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48599       };
48600     } catch (...) {
48601       {
48602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48603       };
48604     }
48605   }
48606   jresult = result;
48607   return jresult;
48608 }
48609
48610
48611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
48612   void * jresult ;
48613   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
48614
48615   {
48616     try {
48617       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
48618     } catch (std::out_of_range& e) {
48619       {
48620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48621       };
48622     } catch (std::exception& e) {
48623       {
48624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48625       };
48626     } catch (...) {
48627       {
48628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48629       };
48630     }
48631   }
48632   jresult = (void *)result;
48633   return jresult;
48634 }
48635
48636
48637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
48638   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
48639
48640   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
48641   {
48642     try {
48643       delete arg1;
48644     } catch (std::out_of_range& e) {
48645       {
48646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48647       };
48648     } catch (std::exception& e) {
48649       {
48650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48651       };
48652     } catch (...) {
48653       {
48654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48655       };
48656     }
48657   }
48658 }
48659
48660
48661 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
48662   unsigned int jresult ;
48663   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
48664   bool result;
48665
48666   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
48667   {
48668     try {
48669       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
48670     } catch (std::out_of_range& e) {
48671       {
48672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48673       };
48674     } catch (std::exception& e) {
48675       {
48676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48677       };
48678     } catch (...) {
48679       {
48680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48681       };
48682     }
48683   }
48684   jresult = result;
48685   return jresult;
48686 }
48687
48688
48689 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
48690   unsigned long jresult ;
48691   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
48692   std::size_t result;
48693
48694   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
48695   {
48696     try {
48697       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
48698     } catch (std::out_of_range& e) {
48699       {
48700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48701       };
48702     } catch (std::exception& e) {
48703       {
48704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48705       };
48706     } catch (...) {
48707       {
48708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48709       };
48710     }
48711   }
48712   jresult = (unsigned long)result;
48713   return jresult;
48714 }
48715
48716
48717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
48718   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
48719   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
48720
48721   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
48722   arg2 = (void (*)(Dali::Actor))jarg2;
48723   {
48724     try {
48725       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
48726     } catch (std::out_of_range& e) {
48727       {
48728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48729       };
48730     } catch (std::exception& e) {
48731       {
48732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48733       };
48734     } catch (...) {
48735       {
48736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48737       };
48738     }
48739   }
48740 }
48741
48742
48743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
48744   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
48745   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
48746
48747   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
48748   arg2 = (void (*)(Dali::Actor))jarg2;
48749   {
48750     try {
48751       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
48752     } catch (std::out_of_range& e) {
48753       {
48754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48755       };
48756     } catch (std::exception& e) {
48757       {
48758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48759       };
48760     } catch (...) {
48761       {
48762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48763       };
48764     }
48765   }
48766 }
48767
48768
48769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
48770   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
48771   Dali::Actor arg2 ;
48772   Dali::Actor *argp2 ;
48773
48774   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
48775   argp2 = (Dali::Actor *)jarg2;
48776   if (!argp2) {
48777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48778     return ;
48779   }
48780   arg2 = *argp2;
48781   {
48782     try {
48783       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
48784     } catch (std::out_of_range& e) {
48785       {
48786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48787       };
48788     } catch (std::exception& e) {
48789       {
48790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48791       };
48792     } catch (...) {
48793       {
48794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48795       };
48796     }
48797   }
48798 }
48799
48800
48801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
48802   void * jresult ;
48803   Dali::Signal< void (Dali::Actor) > *result = 0 ;
48804
48805   {
48806     try {
48807       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
48808     } catch (std::out_of_range& e) {
48809       {
48810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48811       };
48812     } catch (std::exception& e) {
48813       {
48814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48815       };
48816     } catch (...) {
48817       {
48818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48819       };
48820     }
48821   }
48822   jresult = (void *)result;
48823   return jresult;
48824 }
48825
48826
48827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
48828   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
48829
48830   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
48831   {
48832     try {
48833       delete arg1;
48834     } catch (std::out_of_range& e) {
48835       {
48836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48837       };
48838     } catch (std::exception& e) {
48839       {
48840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48841       };
48842     } catch (...) {
48843       {
48844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48845       };
48846     }
48847   }
48848 }
48849
48850
48851 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
48852   unsigned int jresult ;
48853   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
48854   bool result;
48855
48856   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
48857   {
48858     try {
48859       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
48860     } catch (std::out_of_range& e) {
48861       {
48862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48863       };
48864     } catch (std::exception& e) {
48865       {
48866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48867       };
48868     } catch (...) {
48869       {
48870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48871       };
48872     }
48873   }
48874   jresult = result;
48875   return jresult;
48876 }
48877
48878
48879 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
48880   unsigned long jresult ;
48881   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
48882   std::size_t result;
48883
48884   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
48885   {
48886     try {
48887       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
48888     } catch (std::out_of_range& e) {
48889       {
48890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48891       };
48892     } catch (std::exception& e) {
48893       {
48894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48895       };
48896     } catch (...) {
48897       {
48898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48899       };
48900     }
48901   }
48902   jresult = (unsigned long)result;
48903   return jresult;
48904 }
48905
48906
48907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
48908   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
48909   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
48910
48911   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
48912   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
48913   {
48914     try {
48915       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
48916     } catch (std::out_of_range& e) {
48917       {
48918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48919       };
48920     } catch (std::exception& e) {
48921       {
48922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48923       };
48924     } catch (...) {
48925       {
48926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48927       };
48928     }
48929   }
48930 }
48931
48932
48933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
48934   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
48935   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
48936
48937   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
48938   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
48939   {
48940     try {
48941       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
48942     } catch (std::out_of_range& e) {
48943       {
48944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48945       };
48946     } catch (std::exception& e) {
48947       {
48948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48949       };
48950     } catch (...) {
48951       {
48952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48953       };
48954     }
48955   }
48956 }
48957
48958
48959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
48960   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
48961   Dali::KeyEvent *arg2 = 0 ;
48962
48963   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
48964   arg2 = (Dali::KeyEvent *)jarg2;
48965   if (!arg2) {
48966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
48967     return ;
48968   }
48969   {
48970     try {
48971       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
48972     } catch (std::out_of_range& e) {
48973       {
48974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48975       };
48976     } catch (std::exception& e) {
48977       {
48978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48979       };
48980     } catch (...) {
48981       {
48982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48983       };
48984     }
48985   }
48986 }
48987
48988
48989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
48990   void * jresult ;
48991   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
48992
48993   {
48994     try {
48995       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
48996     } catch (std::out_of_range& e) {
48997       {
48998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48999       };
49000     } catch (std::exception& e) {
49001       {
49002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49003       };
49004     } catch (...) {
49005       {
49006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49007       };
49008     }
49009   }
49010   jresult = (void *)result;
49011   return jresult;
49012 }
49013
49014
49015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
49016   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
49017
49018   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
49019   {
49020     try {
49021       delete arg1;
49022     } catch (std::out_of_range& e) {
49023       {
49024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49025       };
49026     } catch (std::exception& e) {
49027       {
49028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49029       };
49030     } catch (...) {
49031       {
49032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49033       };
49034     }
49035   }
49036 }
49037
49038
49039 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
49040   unsigned int jresult ;
49041   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
49042   bool result;
49043
49044   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
49045   {
49046     try {
49047       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
49048     } catch (std::out_of_range& e) {
49049       {
49050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49051       };
49052     } catch (std::exception& e) {
49053       {
49054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49055       };
49056     } catch (...) {
49057       {
49058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49059       };
49060     }
49061   }
49062   jresult = result;
49063   return jresult;
49064 }
49065
49066
49067 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
49068   unsigned long jresult ;
49069   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
49070   std::size_t result;
49071
49072   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
49073   {
49074     try {
49075       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
49076     } catch (std::out_of_range& e) {
49077       {
49078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49079       };
49080     } catch (std::exception& e) {
49081       {
49082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49083       };
49084     } catch (...) {
49085       {
49086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49087       };
49088     }
49089   }
49090   jresult = (unsigned long)result;
49091   return jresult;
49092 }
49093
49094
49095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
49096   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
49097   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
49098
49099   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
49100   arg2 = (void (*)(Dali::TouchData const &))jarg2;
49101   {
49102     try {
49103       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49104     } catch (std::out_of_range& e) {
49105       {
49106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49107       };
49108     } catch (std::exception& e) {
49109       {
49110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49111       };
49112     } catch (...) {
49113       {
49114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49115       };
49116     }
49117   }
49118 }
49119
49120
49121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
49122   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
49123   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
49124
49125   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
49126   arg2 = (void (*)(Dali::TouchData const &))jarg2;
49127   {
49128     try {
49129       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
49130     } catch (std::out_of_range& e) {
49131       {
49132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49133       };
49134     } catch (std::exception& e) {
49135       {
49136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49137       };
49138     } catch (...) {
49139       {
49140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49141       };
49142     }
49143   }
49144 }
49145
49146
49147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
49148   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
49149   Dali::TouchData *arg2 = 0 ;
49150
49151   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
49152   arg2 = (Dali::TouchData *)jarg2;
49153   if (!arg2) {
49154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
49155     return ;
49156   }
49157   {
49158     try {
49159       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
49160     } catch (std::out_of_range& e) {
49161       {
49162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49163       };
49164     } catch (std::exception& e) {
49165       {
49166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49167       };
49168     } catch (...) {
49169       {
49170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49171       };
49172     }
49173   }
49174 }
49175
49176
49177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
49178   void * jresult ;
49179   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
49180
49181   {
49182     try {
49183       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
49184     } catch (std::out_of_range& e) {
49185       {
49186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49187       };
49188     } catch (std::exception& e) {
49189       {
49190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49191       };
49192     } catch (...) {
49193       {
49194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49195       };
49196     }
49197   }
49198   jresult = (void *)result;
49199   return jresult;
49200 }
49201
49202
49203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
49204   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
49205
49206   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
49207   {
49208     try {
49209       delete arg1;
49210     } catch (std::out_of_range& e) {
49211       {
49212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49213       };
49214     } catch (std::exception& e) {
49215       {
49216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49217       };
49218     } catch (...) {
49219       {
49220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49221       };
49222     }
49223   }
49224 }
49225
49226
49227 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
49228   unsigned int jresult ;
49229   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
49230   bool result;
49231
49232   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
49233   {
49234     try {
49235       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
49236     } catch (std::out_of_range& e) {
49237       {
49238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49239       };
49240     } catch (std::exception& e) {
49241       {
49242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49243       };
49244     } catch (...) {
49245       {
49246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49247       };
49248     }
49249   }
49250   jresult = result;
49251   return jresult;
49252 }
49253
49254
49255 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
49256   unsigned long jresult ;
49257   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
49258   std::size_t result;
49259
49260   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
49261   {
49262     try {
49263       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
49264     } catch (std::out_of_range& e) {
49265       {
49266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49267       };
49268     } catch (std::exception& e) {
49269       {
49270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49271       };
49272     } catch (...) {
49273       {
49274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49275       };
49276     }
49277   }
49278   jresult = (unsigned long)result;
49279   return jresult;
49280 }
49281
49282
49283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
49284   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
49285   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
49286
49287   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
49288   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
49289   {
49290     try {
49291       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49292     } catch (std::out_of_range& e) {
49293       {
49294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49295       };
49296     } catch (std::exception& e) {
49297       {
49298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49299       };
49300     } catch (...) {
49301       {
49302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49303       };
49304     }
49305   }
49306 }
49307
49308
49309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
49310   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
49311   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
49312
49313   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
49314   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
49315   {
49316     try {
49317       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
49318     } catch (std::out_of_range& e) {
49319       {
49320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49321       };
49322     } catch (std::exception& e) {
49323       {
49324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49325       };
49326     } catch (...) {
49327       {
49328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49329       };
49330     }
49331   }
49332 }
49333
49334
49335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
49336   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
49337   Dali::WheelEvent *arg2 = 0 ;
49338
49339   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
49340   arg2 = (Dali::WheelEvent *)jarg2;
49341   if (!arg2) {
49342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
49343     return ;
49344   }
49345   {
49346     try {
49347       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
49348     } catch (std::out_of_range& e) {
49349       {
49350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49351       };
49352     } catch (std::exception& e) {
49353       {
49354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49355       };
49356     } catch (...) {
49357       {
49358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49359       };
49360     }
49361   }
49362 }
49363
49364
49365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
49366   void * jresult ;
49367   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
49368
49369   {
49370     try {
49371       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
49372     } catch (std::out_of_range& e) {
49373       {
49374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49375       };
49376     } catch (std::exception& e) {
49377       {
49378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49379       };
49380     } catch (...) {
49381       {
49382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49383       };
49384     }
49385   }
49386   jresult = (void *)result;
49387   return jresult;
49388 }
49389
49390
49391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
49392   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
49393
49394   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
49395   {
49396     try {
49397       delete arg1;
49398     } catch (std::out_of_range& e) {
49399       {
49400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49401       };
49402     } catch (std::exception& e) {
49403       {
49404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49405       };
49406     } catch (...) {
49407       {
49408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49409       };
49410     }
49411   }
49412 }
49413
49414
49415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
49416   void * jresult ;
49417   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
49418
49419   {
49420     try {
49421       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
49422     } catch (std::out_of_range& e) {
49423       {
49424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49425       };
49426     } catch (std::exception& e) {
49427       {
49428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49429       };
49430     } catch (...) {
49431       {
49432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49433       };
49434     }
49435   }
49436   jresult = (void *)result;
49437   return jresult;
49438 }
49439
49440
49441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
49442   void * jresult ;
49443   Dali::Radian arg1 ;
49444   Dali::Radian arg2 ;
49445   Dali::Radian *argp1 ;
49446   Dali::Radian *argp2 ;
49447   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
49448
49449   argp1 = (Dali::Radian *)jarg1;
49450   if (!argp1) {
49451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
49452     return 0;
49453   }
49454   arg1 = *argp1;
49455   argp2 = (Dali::Radian *)jarg2;
49456   if (!argp2) {
49457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
49458     return 0;
49459   }
49460   arg2 = *argp2;
49461   {
49462     try {
49463       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
49464     } catch (std::out_of_range& e) {
49465       {
49466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49467       };
49468     } catch (std::exception& e) {
49469       {
49470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49471       };
49472     } catch (...) {
49473       {
49474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49475       };
49476     }
49477   }
49478   jresult = (void *)result;
49479   return jresult;
49480 }
49481
49482
49483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
49484   void * jresult ;
49485   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
49486   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
49487
49488   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
49489   if (!arg1) {
49490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
49491     return 0;
49492   }
49493   {
49494     try {
49495       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
49496     } catch (std::out_of_range& e) {
49497       {
49498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49499       };
49500     } catch (std::exception& e) {
49501       {
49502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49503       };
49504     } catch (...) {
49505       {
49506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49507       };
49508     }
49509   }
49510   jresult = (void *)result;
49511   return jresult;
49512 }
49513
49514
49515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
49516   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
49517   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
49518
49519   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
49520   arg2 = (Dali::Radian *)jarg2;
49521   if (arg1) (arg1)->first = *arg2;
49522 }
49523
49524
49525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
49526   void * jresult ;
49527   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
49528   Dali::Radian *result = 0 ;
49529
49530   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
49531   result = (Dali::Radian *)& ((arg1)->first);
49532   jresult = (void *)result;
49533   return jresult;
49534 }
49535
49536
49537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
49538   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
49539   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
49540
49541   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
49542   arg2 = (Dali::Radian *)jarg2;
49543   if (arg1) (arg1)->second = *arg2;
49544 }
49545
49546
49547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
49548   void * jresult ;
49549   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
49550   Dali::Radian *result = 0 ;
49551
49552   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
49553   result = (Dali::Radian *)& ((arg1)->second);
49554   jresult = (void *)result;
49555   return jresult;
49556 }
49557
49558
49559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
49560   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
49561
49562   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
49563   {
49564     try {
49565       delete arg1;
49566     } catch (std::out_of_range& e) {
49567       {
49568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49569       };
49570     } catch (std::exception& e) {
49571       {
49572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49573       };
49574     } catch (...) {
49575       {
49576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49577       };
49578     }
49579   }
49580 }
49581
49582
49583 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
49584   unsigned int jresult ;
49585   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
49586   bool result;
49587
49588   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
49589   {
49590     try {
49591       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);
49592     } catch (std::out_of_range& e) {
49593       {
49594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49595       };
49596     } catch (std::exception& e) {
49597       {
49598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49599       };
49600     } catch (...) {
49601       {
49602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49603       };
49604     }
49605   }
49606   jresult = result;
49607   return jresult;
49608 }
49609
49610
49611 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
49612   unsigned long jresult ;
49613   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
49614   std::size_t result;
49615
49616   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
49617   {
49618     try {
49619       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);
49620     } catch (std::out_of_range& e) {
49621       {
49622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49623       };
49624     } catch (std::exception& e) {
49625       {
49626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49627       };
49628     } catch (...) {
49629       {
49630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49631       };
49632     }
49633   }
49634   jresult = (unsigned long)result;
49635   return jresult;
49636 }
49637
49638
49639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
49640   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
49641   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
49642
49643   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
49644   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
49645   {
49646     try {
49647       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49648     } catch (std::out_of_range& e) {
49649       {
49650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49651       };
49652     } catch (std::exception& e) {
49653       {
49654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49655       };
49656     } catch (...) {
49657       {
49658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49659       };
49660     }
49661   }
49662 }
49663
49664
49665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
49666   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
49667   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
49668
49669   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
49670   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
49671   {
49672     try {
49673       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
49674     } catch (std::out_of_range& e) {
49675       {
49676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49677       };
49678     } catch (std::exception& e) {
49679       {
49680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49681       };
49682     } catch (...) {
49683       {
49684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49685       };
49686     }
49687   }
49688 }
49689
49690
49691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
49692   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
49693   Dali::Actor arg2 ;
49694   Dali::PanGesture *arg3 = 0 ;
49695   Dali::Actor *argp2 ;
49696
49697   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
49698   argp2 = (Dali::Actor *)jarg2;
49699   if (!argp2) {
49700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49701     return ;
49702   }
49703   arg2 = *argp2;
49704   arg3 = (Dali::PanGesture *)jarg3;
49705   if (!arg3) {
49706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
49707     return ;
49708   }
49709   {
49710     try {
49711       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
49712     } catch (std::out_of_range& e) {
49713       {
49714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49715       };
49716     } catch (std::exception& e) {
49717       {
49718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49719       };
49720     } catch (...) {
49721       {
49722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49723       };
49724     }
49725   }
49726 }
49727
49728
49729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
49730   void * jresult ;
49731   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
49732
49733   {
49734     try {
49735       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
49736     } catch (std::out_of_range& e) {
49737       {
49738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49739       };
49740     } catch (std::exception& e) {
49741       {
49742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49743       };
49744     } catch (...) {
49745       {
49746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49747       };
49748     }
49749   }
49750   jresult = (void *)result;
49751   return jresult;
49752 }
49753
49754
49755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
49756   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
49757
49758   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
49759   {
49760     try {
49761       delete arg1;
49762     } catch (std::out_of_range& e) {
49763       {
49764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49765       };
49766     } catch (std::exception& e) {
49767       {
49768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49769       };
49770     } catch (...) {
49771       {
49772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49773       };
49774     }
49775   }
49776 }
49777
49778
49779 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
49780   unsigned int jresult ;
49781   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
49782   bool result;
49783
49784   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
49785   {
49786     try {
49787       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);
49788     } catch (std::out_of_range& e) {
49789       {
49790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49791       };
49792     } catch (std::exception& e) {
49793       {
49794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49795       };
49796     } catch (...) {
49797       {
49798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49799       };
49800     }
49801   }
49802   jresult = result;
49803   return jresult;
49804 }
49805
49806
49807 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
49808   unsigned long jresult ;
49809   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
49810   std::size_t result;
49811
49812   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
49813   {
49814     try {
49815       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);
49816     } catch (std::out_of_range& e) {
49817       {
49818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49819       };
49820     } catch (std::exception& e) {
49821       {
49822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49823       };
49824     } catch (...) {
49825       {
49826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49827       };
49828     }
49829   }
49830   jresult = (unsigned long)result;
49831   return jresult;
49832 }
49833
49834
49835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
49836   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
49837   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
49838
49839   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
49840   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
49841   {
49842     try {
49843       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49844     } catch (std::out_of_range& e) {
49845       {
49846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49847       };
49848     } catch (std::exception& e) {
49849       {
49850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49851       };
49852     } catch (...) {
49853       {
49854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49855       };
49856     }
49857   }
49858 }
49859
49860
49861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
49862   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
49863   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
49864
49865   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
49866   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
49867   {
49868     try {
49869       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
49870     } catch (std::out_of_range& e) {
49871       {
49872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49873       };
49874     } catch (std::exception& e) {
49875       {
49876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49877       };
49878     } catch (...) {
49879       {
49880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49881       };
49882     }
49883   }
49884 }
49885
49886
49887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
49888   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
49889   Dali::Actor arg2 ;
49890   Dali::PinchGesture *arg3 = 0 ;
49891   Dali::Actor *argp2 ;
49892
49893   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
49894   argp2 = (Dali::Actor *)jarg2;
49895   if (!argp2) {
49896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49897     return ;
49898   }
49899   arg2 = *argp2;
49900   arg3 = (Dali::PinchGesture *)jarg3;
49901   if (!arg3) {
49902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
49903     return ;
49904   }
49905   {
49906     try {
49907       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
49908     } catch (std::out_of_range& e) {
49909       {
49910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49911       };
49912     } catch (std::exception& e) {
49913       {
49914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49915       };
49916     } catch (...) {
49917       {
49918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49919       };
49920     }
49921   }
49922 }
49923
49924
49925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
49926   void * jresult ;
49927   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
49928
49929   {
49930     try {
49931       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
49932     } catch (std::out_of_range& e) {
49933       {
49934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49935       };
49936     } catch (std::exception& e) {
49937       {
49938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49939       };
49940     } catch (...) {
49941       {
49942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49943       };
49944     }
49945   }
49946   jresult = (void *)result;
49947   return jresult;
49948 }
49949
49950
49951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
49952   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
49953
49954   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
49955   {
49956     try {
49957       delete arg1;
49958     } catch (std::out_of_range& e) {
49959       {
49960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49961       };
49962     } catch (std::exception& e) {
49963       {
49964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49965       };
49966     } catch (...) {
49967       {
49968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49969       };
49970     }
49971   }
49972 }
49973
49974
49975 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
49976   unsigned int jresult ;
49977   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
49978   bool result;
49979
49980   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
49981   {
49982     try {
49983       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);
49984     } catch (std::out_of_range& e) {
49985       {
49986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49987       };
49988     } catch (std::exception& e) {
49989       {
49990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49991       };
49992     } catch (...) {
49993       {
49994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49995       };
49996     }
49997   }
49998   jresult = result;
49999   return jresult;
50000 }
50001
50002
50003 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
50004   unsigned long jresult ;
50005   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
50006   std::size_t result;
50007
50008   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
50009   {
50010     try {
50011       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);
50012     } catch (std::out_of_range& e) {
50013       {
50014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50015       };
50016     } catch (std::exception& e) {
50017       {
50018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50019       };
50020     } catch (...) {
50021       {
50022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50023       };
50024     }
50025   }
50026   jresult = (unsigned long)result;
50027   return jresult;
50028 }
50029
50030
50031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
50032   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
50033   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
50034
50035   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
50036   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
50037   {
50038     try {
50039       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50040     } catch (std::out_of_range& e) {
50041       {
50042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50043       };
50044     } catch (std::exception& e) {
50045       {
50046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50047       };
50048     } catch (...) {
50049       {
50050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50051       };
50052     }
50053   }
50054 }
50055
50056
50057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
50058   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
50059   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
50060
50061   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
50062   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
50063   {
50064     try {
50065       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50066     } catch (std::out_of_range& e) {
50067       {
50068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50069       };
50070     } catch (std::exception& e) {
50071       {
50072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50073       };
50074     } catch (...) {
50075       {
50076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50077       };
50078     }
50079   }
50080 }
50081
50082
50083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50084   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
50085   Dali::Actor arg2 ;
50086   Dali::TapGesture *arg3 = 0 ;
50087   Dali::Actor *argp2 ;
50088
50089   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
50090   argp2 = (Dali::Actor *)jarg2;
50091   if (!argp2) {
50092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50093     return ;
50094   }
50095   arg2 = *argp2;
50096   arg3 = (Dali::TapGesture *)jarg3;
50097   if (!arg3) {
50098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
50099     return ;
50100   }
50101   {
50102     try {
50103       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
50104     } catch (std::out_of_range& e) {
50105       {
50106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50107       };
50108     } catch (std::exception& e) {
50109       {
50110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50111       };
50112     } catch (...) {
50113       {
50114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50115       };
50116     }
50117   }
50118 }
50119
50120
50121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
50122   void * jresult ;
50123   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
50124
50125   {
50126     try {
50127       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
50128     } catch (std::out_of_range& e) {
50129       {
50130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50131       };
50132     } catch (std::exception& e) {
50133       {
50134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50135       };
50136     } catch (...) {
50137       {
50138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50139       };
50140     }
50141   }
50142   jresult = (void *)result;
50143   return jresult;
50144 }
50145
50146
50147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
50148   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
50149
50150   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
50151   {
50152     try {
50153       delete arg1;
50154     } catch (std::out_of_range& e) {
50155       {
50156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50157       };
50158     } catch (std::exception& e) {
50159       {
50160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50161       };
50162     } catch (...) {
50163       {
50164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50165       };
50166     }
50167   }
50168 }
50169
50170 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
50171   unsigned int jresult ;
50172   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
50173   bool result;
50174
50175   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
50176   {
50177     try {
50178       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
50179     } catch (std::out_of_range& e) {
50180       {
50181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50182       };
50183     } catch (std::exception& e) {
50184       {
50185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50186       };
50187     } catch (...) {
50188       {
50189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50190       };
50191     }
50192   }
50193   jresult = result;
50194   return jresult;
50195 }
50196
50197
50198 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
50199   unsigned long jresult ;
50200   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
50201   std::size_t result;
50202
50203   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
50204   {
50205     try {
50206       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
50207     } catch (std::out_of_range& e) {
50208       {
50209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50210       };
50211     } catch (std::exception& e) {
50212       {
50213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50214       };
50215     } catch (...) {
50216       {
50217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50218       };
50219     }
50220   }
50221   jresult = (unsigned long)result;
50222   return jresult;
50223 }
50224
50225
50226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
50227   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
50228   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
50229
50230   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
50231   arg2 = (void (*)(Dali::ResourceImage))jarg2;
50232   {
50233     try {
50234       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
50235     } catch (std::out_of_range& e) {
50236       {
50237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50238       };
50239     } catch (std::exception& e) {
50240       {
50241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50242       };
50243     } catch (...) {
50244       {
50245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50246       };
50247     }
50248   }
50249 }
50250
50251
50252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
50253   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
50254   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
50255
50256   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
50257   arg2 = (void (*)(Dali::ResourceImage))jarg2;
50258   {
50259     try {
50260       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
50261     } catch (std::out_of_range& e) {
50262       {
50263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50264       };
50265     } catch (std::exception& e) {
50266       {
50267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50268       };
50269     } catch (...) {
50270       {
50271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50272       };
50273     }
50274   }
50275 }
50276
50277
50278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
50279   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
50280   Dali::ResourceImage arg2 ;
50281   Dali::ResourceImage *argp2 ;
50282
50283   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
50284   argp2 = (Dali::ResourceImage *)jarg2;
50285   if (!argp2) {
50286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
50287     return ;
50288   }
50289   arg2 = *argp2;
50290   {
50291     try {
50292       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
50293     } catch (std::out_of_range& e) {
50294       {
50295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50296       };
50297     } catch (std::exception& e) {
50298       {
50299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50300       };
50301     } catch (...) {
50302       {
50303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50304       };
50305     }
50306   }
50307 }
50308
50309
50310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
50311   void * jresult ;
50312   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
50313
50314   {
50315     try {
50316       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
50317     } catch (std::out_of_range& e) {
50318       {
50319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50320       };
50321     } catch (std::exception& e) {
50322       {
50323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50324       };
50325     } catch (...) {
50326       {
50327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50328       };
50329     }
50330   }
50331   jresult = (void *)result;
50332   return jresult;
50333 }
50334
50335
50336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
50337   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
50338
50339   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
50340   {
50341     try {
50342       delete arg1;
50343     } catch (std::out_of_range& e) {
50344       {
50345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50346       };
50347     } catch (std::exception& e) {
50348       {
50349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50350       };
50351     } catch (...) {
50352       {
50353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50354       };
50355     }
50356   }
50357 }
50358
50359
50360 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
50361   unsigned int jresult ;
50362   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
50363   bool result;
50364
50365   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
50366   {
50367     try {
50368       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);
50369     } catch (std::out_of_range& e) {
50370       {
50371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50372       };
50373     } catch (std::exception& e) {
50374       {
50375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50376       };
50377     } catch (...) {
50378       {
50379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50380       };
50381     }
50382   }
50383   jresult = result;
50384   return jresult;
50385 }
50386
50387
50388 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
50389   unsigned long jresult ;
50390   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
50391   std::size_t result;
50392
50393   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
50394   {
50395     try {
50396       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);
50397     } catch (std::out_of_range& e) {
50398       {
50399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50400       };
50401     } catch (std::exception& e) {
50402       {
50403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50404       };
50405     } catch (...) {
50406       {
50407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50408       };
50409     }
50410   }
50411   jresult = (unsigned long)result;
50412   return jresult;
50413 }
50414
50415
50416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
50417   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
50418   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
50419
50420   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
50421   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
50422   {
50423     try {
50424       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
50425     } catch (std::out_of_range& e) {
50426       {
50427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50428       };
50429     } catch (std::exception& e) {
50430       {
50431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50432       };
50433     } catch (...) {
50434       {
50435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50436       };
50437     }
50438   }
50439 }
50440
50441
50442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
50443   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
50444   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
50445
50446   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
50447   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
50448   {
50449     try {
50450       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
50451     } catch (std::out_of_range& e) {
50452       {
50453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50454       };
50455     } catch (std::exception& e) {
50456       {
50457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50458       };
50459     } catch (...) {
50460       {
50461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50462       };
50463     }
50464   }
50465 }
50466
50467
50468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
50469   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
50470   Dali::Actor arg2 ;
50471   bool arg3 ;
50472   Dali::DevelActor::VisibilityChange::Type arg4 ;
50473   Dali::Actor *argp2 ;
50474
50475   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
50476   argp2 = (Dali::Actor *)jarg2;
50477   if (!argp2) {
50478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50479     return ;
50480   }
50481   arg2 = *argp2;
50482   arg3 = jarg3 ? true : false;
50483   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
50484   {
50485     try {
50486       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
50487     } catch (std::out_of_range& e) {
50488       {
50489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50490       };
50491     } catch (std::exception& e) {
50492       {
50493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50494       };
50495     } catch (...) {
50496       {
50497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50498       };
50499     }
50500   }
50501 }
50502
50503
50504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
50505   void * jresult ;
50506   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
50507
50508   {
50509     try {
50510       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
50511     } catch (std::out_of_range& e) {
50512       {
50513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50514       };
50515     } catch (std::exception& e) {
50516       {
50517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50518       };
50519     } catch (...) {
50520       {
50521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50522       };
50523     }
50524   }
50525   jresult = (void *)result;
50526   return jresult;
50527 }
50528
50529
50530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
50531   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
50532
50533   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
50534   {
50535     try {
50536       delete arg1;
50537     } catch (std::out_of_range& e) {
50538       {
50539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50540       };
50541     } catch (std::exception& e) {
50542       {
50543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50544       };
50545     } catch (...) {
50546       {
50547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50548       };
50549     }
50550   }
50551 }
50552
50553
50554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
50555   void * jresult ;
50556   Dali::Timer *result = 0 ;
50557
50558   {
50559     try {
50560       result = (Dali::Timer *)new Dali::Timer();
50561     } catch (std::out_of_range& e) {
50562       {
50563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50564       };
50565     } catch (std::exception& e) {
50566       {
50567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50568       };
50569     } catch (...) {
50570       {
50571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50572       };
50573     }
50574   }
50575   jresult = (void *)result;
50576   return jresult;
50577 }
50578
50579
50580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
50581   void * jresult ;
50582   unsigned int arg1 ;
50583   Dali::Timer result;
50584
50585   arg1 = (unsigned int)jarg1;
50586   {
50587     try {
50588       result = Dali::Timer::New(arg1);
50589     } catch (std::out_of_range& e) {
50590       {
50591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50592       };
50593     } catch (std::exception& e) {
50594       {
50595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50596       };
50597     } catch (...) {
50598       {
50599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50600       };
50601     }
50602   }
50603   jresult = new Dali::Timer((const Dali::Timer &)result);
50604   return jresult;
50605 }
50606
50607
50608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
50609   void * jresult ;
50610   Dali::Timer *arg1 = 0 ;
50611   Dali::Timer *result = 0 ;
50612
50613   arg1 = (Dali::Timer *)jarg1;
50614   if (!arg1) {
50615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
50616     return 0;
50617   }
50618   {
50619     try {
50620       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
50621     } catch (std::out_of_range& e) {
50622       {
50623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50624       };
50625     } catch (std::exception& e) {
50626       {
50627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50628       };
50629     } catch (...) {
50630       {
50631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50632       };
50633     }
50634   }
50635   jresult = (void *)result;
50636   return jresult;
50637 }
50638
50639
50640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
50641   void * jresult ;
50642   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50643   Dali::Timer *arg2 = 0 ;
50644   Dali::Timer *result = 0 ;
50645
50646   arg1 = (Dali::Timer *)jarg1;
50647   arg2 = (Dali::Timer *)jarg2;
50648   if (!arg2) {
50649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
50650     return 0;
50651   }
50652   {
50653     try {
50654       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
50655     } catch (std::out_of_range& e) {
50656       {
50657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50658       };
50659     } catch (std::exception& e) {
50660       {
50661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50662       };
50663     } catch (...) {
50664       {
50665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50666       };
50667     }
50668   }
50669   jresult = (void *)result;
50670   return jresult;
50671 }
50672
50673
50674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
50675   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50676
50677   arg1 = (Dali::Timer *)jarg1;
50678   {
50679     try {
50680       delete arg1;
50681     } catch (std::out_of_range& e) {
50682       {
50683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50684       };
50685     } catch (std::exception& e) {
50686       {
50687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50688       };
50689     } catch (...) {
50690       {
50691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50692       };
50693     }
50694   }
50695 }
50696
50697
50698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
50699   void * jresult ;
50700   Dali::BaseHandle arg1 ;
50701   Dali::BaseHandle *argp1 ;
50702   Dali::Timer result;
50703
50704   argp1 = (Dali::BaseHandle *)jarg1;
50705   if (!argp1) {
50706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50707     return 0;
50708   }
50709   arg1 = *argp1;
50710   {
50711     try {
50712       result = Dali::Timer::DownCast(arg1);
50713     } catch (std::out_of_range& e) {
50714       {
50715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50716       };
50717     } catch (std::exception& e) {
50718       {
50719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50720       };
50721     } catch (...) {
50722       {
50723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50724       };
50725     }
50726   }
50727   jresult = new Dali::Timer((const Dali::Timer &)result);
50728   return jresult;
50729 }
50730
50731
50732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
50733   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50734
50735   arg1 = (Dali::Timer *)jarg1;
50736   {
50737     try {
50738       (arg1)->Start();
50739     } catch (std::out_of_range& e) {
50740       {
50741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50742       };
50743     } catch (std::exception& e) {
50744       {
50745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50746       };
50747     } catch (...) {
50748       {
50749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50750       };
50751     }
50752   }
50753 }
50754
50755
50756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
50757   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50758
50759   arg1 = (Dali::Timer *)jarg1;
50760   {
50761     try {
50762       (arg1)->Stop();
50763     } catch (std::out_of_range& e) {
50764       {
50765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50766       };
50767     } catch (std::exception& e) {
50768       {
50769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50770       };
50771     } catch (...) {
50772       {
50773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50774       };
50775     }
50776   }
50777 }
50778
50779
50780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
50781   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50782   unsigned int arg2 ;
50783
50784   arg1 = (Dali::Timer *)jarg1;
50785   arg2 = (unsigned int)jarg2;
50786   {
50787     try {
50788       (arg1)->SetInterval(arg2);
50789     } catch (std::out_of_range& e) {
50790       {
50791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50792       };
50793     } catch (std::exception& e) {
50794       {
50795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50796       };
50797     } catch (...) {
50798       {
50799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50800       };
50801     }
50802   }
50803 }
50804
50805
50806 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
50807   unsigned int jresult ;
50808   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50809   unsigned int result;
50810
50811   arg1 = (Dali::Timer *)jarg1;
50812   {
50813     try {
50814       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
50815     } catch (std::out_of_range& e) {
50816       {
50817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50818       };
50819     } catch (std::exception& e) {
50820       {
50821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50822       };
50823     } catch (...) {
50824       {
50825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50826       };
50827     }
50828   }
50829   jresult = result;
50830   return jresult;
50831 }
50832
50833
50834 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
50835   unsigned int jresult ;
50836   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50837   bool result;
50838
50839   arg1 = (Dali::Timer *)jarg1;
50840   {
50841     try {
50842       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
50843     } catch (std::out_of_range& e) {
50844       {
50845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50846       };
50847     } catch (std::exception& e) {
50848       {
50849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50850       };
50851     } catch (...) {
50852       {
50853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50854       };
50855     }
50856   }
50857   jresult = result;
50858   return jresult;
50859 }
50860
50861
50862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
50863   void * jresult ;
50864   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50865   Dali::Timer::TimerSignalType *result = 0 ;
50866
50867   arg1 = (Dali::Timer *)jarg1;
50868   {
50869     try {
50870       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
50871     } catch (std::out_of_range& e) {
50872       {
50873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50874       };
50875     } catch (std::exception& e) {
50876       {
50877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50878       };
50879     } catch (...) {
50880       {
50881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50882       };
50883     }
50884   }
50885   jresult = (void *)result;
50886   return jresult;
50887 }
50888
50889
50890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
50891   void * jresult ;
50892   Dali::DragAndDropDetector *result = 0 ;
50893
50894   {
50895     try {
50896       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
50897     } catch (std::out_of_range& e) {
50898       {
50899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50900       };
50901     } catch (std::exception& e) {
50902       {
50903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50904       };
50905     } catch (...) {
50906       {
50907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50908       };
50909     }
50910   }
50911   jresult = (void *)result;
50912   return jresult;
50913 }
50914
50915
50916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
50917   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
50918
50919   arg1 = (Dali::DragAndDropDetector *)jarg1;
50920   {
50921     try {
50922       delete arg1;
50923     } catch (std::out_of_range& e) {
50924       {
50925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50926       };
50927     } catch (std::exception& e) {
50928       {
50929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50930       };
50931     } catch (...) {
50932       {
50933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50934       };
50935     }
50936   }
50937 }
50938
50939
50940 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
50941   char * jresult ;
50942   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
50943   std::string *result = 0 ;
50944
50945   arg1 = (Dali::DragAndDropDetector *)jarg1;
50946   {
50947     try {
50948       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
50949     } catch (std::out_of_range& e) {
50950       {
50951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50952       };
50953     } catch (std::exception& e) {
50954       {
50955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50956       };
50957     } catch (...) {
50958       {
50959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50960       };
50961     }
50962   }
50963   jresult = SWIG_csharp_string_callback(result->c_str());
50964   return jresult;
50965 }
50966
50967
50968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
50969   void * jresult ;
50970   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
50971   Dali::Vector2 result;
50972
50973   arg1 = (Dali::DragAndDropDetector *)jarg1;
50974   {
50975     try {
50976       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
50977     } catch (std::out_of_range& e) {
50978       {
50979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50980       };
50981     } catch (std::exception& e) {
50982       {
50983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50984       };
50985     } catch (...) {
50986       {
50987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50988       };
50989     }
50990   }
50991   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
50992   return jresult;
50993 }
50994
50995
50996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
50997   void * jresult ;
50998   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
50999   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
51000
51001   arg1 = (Dali::DragAndDropDetector *)jarg1;
51002   {
51003     try {
51004       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
51005     } catch (std::out_of_range& e) {
51006       {
51007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51008       };
51009     } catch (std::exception& e) {
51010       {
51011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51012       };
51013     } catch (...) {
51014       {
51015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51016       };
51017     }
51018   }
51019   jresult = (void *)result;
51020   return jresult;
51021 }
51022
51023
51024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
51025   void * jresult ;
51026   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
51027   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
51028
51029   arg1 = (Dali::DragAndDropDetector *)jarg1;
51030   {
51031     try {
51032       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
51033     } catch (std::out_of_range& e) {
51034       {
51035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51036       };
51037     } catch (std::exception& e) {
51038       {
51039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51040       };
51041     } catch (...) {
51042       {
51043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51044       };
51045     }
51046   }
51047   jresult = (void *)result;
51048   return jresult;
51049 }
51050
51051
51052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
51053   void * jresult ;
51054   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
51055   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
51056
51057   arg1 = (Dali::DragAndDropDetector *)jarg1;
51058   {
51059     try {
51060       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
51061     } catch (std::out_of_range& e) {
51062       {
51063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51064       };
51065     } catch (std::exception& e) {
51066       {
51067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51068       };
51069     } catch (...) {
51070       {
51071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51072       };
51073     }
51074   }
51075   jresult = (void *)result;
51076   return jresult;
51077 }
51078
51079
51080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_DroppedSignal(void * jarg1) {
51081   void * jresult ;
51082   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
51083   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
51084
51085   arg1 = (Dali::DragAndDropDetector *)jarg1;
51086   {
51087     try {
51088       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
51089     } catch (std::out_of_range& e) {
51090       {
51091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51092       };
51093     } catch (std::exception& e) {
51094       {
51095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51096       };
51097     } catch (...) {
51098       {
51099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51100       };
51101     }
51102   }
51103   jresult = (void *)result;
51104   return jresult;
51105 }
51106
51107
51108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_0() {
51109   void * jresult ;
51110   Dali::ApplicationExtensions *result = 0 ;
51111
51112   {
51113     try {
51114       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions();
51115     } catch (std::out_of_range& e) {
51116       {
51117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51118       };
51119     } catch (std::exception& e) {
51120       {
51121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51122       };
51123     } catch (...) {
51124       {
51125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51126       };
51127     }
51128   }
51129   jresult = (void *)result;
51130   return jresult;
51131 }
51132
51133
51134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_1(void * jarg1) {
51135   void * jresult ;
51136   Dali::Application *arg1 = (Dali::Application *) 0 ;
51137   Dali::ApplicationExtensions *result = 0 ;
51138
51139   arg1 = (Dali::Application *)jarg1;
51140   {
51141     try {
51142       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions(arg1);
51143     } catch (std::out_of_range& e) {
51144       {
51145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51146       };
51147     } catch (std::exception& e) {
51148       {
51149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51150       };
51151     } catch (...) {
51152       {
51153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51154       };
51155     }
51156   }
51157   jresult = (void *)result;
51158   return jresult;
51159 }
51160
51161
51162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationExtensions(void * jarg1) {
51163   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51164
51165   arg1 = (Dali::ApplicationExtensions *)jarg1;
51166   {
51167     try {
51168       delete arg1;
51169     } catch (std::out_of_range& e) {
51170       {
51171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51172       };
51173     } catch (std::exception& e) {
51174       {
51175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51176       };
51177     } catch (...) {
51178       {
51179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51180       };
51181     }
51182   }
51183 }
51184
51185
51186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Init(void * jarg1) {
51187   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51188
51189   arg1 = (Dali::ApplicationExtensions *)jarg1;
51190   {
51191     try {
51192       (arg1)->Init();
51193     } catch (std::out_of_range& e) {
51194       {
51195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51196       };
51197     } catch (std::exception& e) {
51198       {
51199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51200       };
51201     } catch (...) {
51202       {
51203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51204       };
51205     }
51206   }
51207 }
51208
51209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Start(void * jarg1) {
51210   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51211
51212   arg1 = (Dali::ApplicationExtensions *)jarg1;
51213   {
51214     try {
51215       (arg1)->Start();
51216     } catch (std::out_of_range& e) {
51217       {
51218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51219       };
51220     } catch (std::exception& e) {
51221       {
51222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51223       };
51224     } catch (...) {
51225       {
51226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51227       };
51228     }
51229   }
51230 }
51231
51232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Terminate(void * jarg1) {
51233   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51234
51235   arg1 = (Dali::ApplicationExtensions *)jarg1;
51236   {
51237     try {
51238       (arg1)->Terminate();
51239     } catch (std::out_of_range& e) {
51240       {
51241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51242       };
51243     } catch (std::exception& e) {
51244       {
51245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51246       };
51247     } catch (...) {
51248       {
51249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51250       };
51251     }
51252   }
51253 }
51254
51255
51256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Pause(void * jarg1) {
51257   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51258
51259   arg1 = (Dali::ApplicationExtensions *)jarg1;
51260   {
51261     try {
51262       (arg1)->Pause();
51263     } catch (std::out_of_range& e) {
51264       {
51265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51266       };
51267     } catch (std::exception& e) {
51268       {
51269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51270       };
51271     } catch (...) {
51272       {
51273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51274       };
51275     }
51276   }
51277 }
51278
51279
51280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Resume(void * jarg1) {
51281   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51282
51283   arg1 = (Dali::ApplicationExtensions *)jarg1;
51284   {
51285     try {
51286       (arg1)->Resume();
51287     } catch (std::out_of_range& e) {
51288       {
51289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51290       };
51291     } catch (std::exception& e) {
51292       {
51293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51294       };
51295     } catch (...) {
51296       {
51297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51298       };
51299     }
51300   }
51301 }
51302
51303
51304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_LanguageChange(void * jarg1) {
51305   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51306
51307   arg1 = (Dali::ApplicationExtensions *)jarg1;
51308   {
51309     try {
51310       (arg1)->LanguageChange();
51311     } catch (std::out_of_range& e) {
51312       {
51313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51314       };
51315     } catch (std::exception& e) {
51316       {
51317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51318       };
51319     } catch (...) {
51320       {
51321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51322       };
51323     }
51324   }
51325 }
51326
51327
51328
51329 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
51330   unsigned int jresult ;
51331   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
51332   bool result;
51333
51334   arg1 = (Dali::Signal< bool () > *)jarg1;
51335   {
51336     try {
51337       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
51338     } catch (std::out_of_range& e) {
51339       {
51340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51341       };
51342     } catch (std::exception& e) {
51343       {
51344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51345       };
51346     } catch (...) {
51347       {
51348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51349       };
51350     }
51351   }
51352   jresult = result;
51353   return jresult;
51354 }
51355
51356
51357 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
51358   unsigned long jresult ;
51359   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
51360   std::size_t result;
51361
51362   arg1 = (Dali::Signal< bool () > *)jarg1;
51363   {
51364     try {
51365       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
51366     } catch (std::out_of_range& e) {
51367       {
51368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51369       };
51370     } catch (std::exception& e) {
51371       {
51372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51373       };
51374     } catch (...) {
51375       {
51376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51377       };
51378     }
51379   }
51380   jresult = (unsigned long)result;
51381   return jresult;
51382 }
51383
51384
51385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
51386   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
51387   bool (*arg2)() = (bool (*)()) 0 ;
51388
51389   arg1 = (Dali::Signal< bool () > *)jarg1;
51390   arg2 = (bool (*)())jarg2;
51391   {
51392     try {
51393       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
51394     } catch (std::out_of_range& e) {
51395       {
51396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51397       };
51398     } catch (std::exception& e) {
51399       {
51400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51401       };
51402     } catch (...) {
51403       {
51404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51405       };
51406     }
51407   }
51408 }
51409
51410
51411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
51412   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
51413   bool (*arg2)() = (bool (*)()) 0 ;
51414
51415   arg1 = (Dali::Signal< bool () > *)jarg1;
51416   arg2 = (bool (*)())jarg2;
51417   {
51418     try {
51419       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
51420     } catch (std::out_of_range& e) {
51421       {
51422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51423       };
51424     } catch (std::exception& e) {
51425       {
51426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51427       };
51428     } catch (...) {
51429       {
51430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51431       };
51432     }
51433   }
51434 }
51435
51436
51437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
51438   unsigned int jresult ;
51439   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
51440   bool result;
51441
51442   arg1 = (Dali::Signal< bool () > *)jarg1;
51443   {
51444     try {
51445       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
51446     } catch (std::out_of_range& e) {
51447       {
51448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51449       };
51450     } catch (std::exception& e) {
51451       {
51452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51453       };
51454     } catch (...) {
51455       {
51456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51457       };
51458     }
51459   }
51460   jresult = result;
51461   return jresult;
51462 }
51463
51464
51465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
51466   void * jresult ;
51467   Dali::Signal< bool () > *result = 0 ;
51468
51469   {
51470     try {
51471       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
51472     } catch (std::out_of_range& e) {
51473       {
51474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51475       };
51476     } catch (std::exception& e) {
51477       {
51478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51479       };
51480     } catch (...) {
51481       {
51482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51483       };
51484     }
51485   }
51486   jresult = (void *)result;
51487   return jresult;
51488 }
51489
51490
51491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
51492   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
51493
51494   arg1 = (Dali::Signal< bool () > *)jarg1;
51495   {
51496     try {
51497       delete arg1;
51498     } catch (std::out_of_range& e) {
51499       {
51500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51501       };
51502     } catch (std::exception& e) {
51503       {
51504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51505       };
51506     } catch (...) {
51507       {
51508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51509       };
51510     }
51511   }
51512 }
51513
51514
51515 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
51516   int jresult ;
51517   int result;
51518
51519   {
51520     try {
51521       result = (int)Dali::Toolkit::Visual::Property::TYPE;
51522     } catch (std::out_of_range& e) {
51523       {
51524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51525       };
51526     } catch (std::exception& e) {
51527       {
51528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51529       };
51530     } catch (...) {
51531       {
51532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51533       };
51534     }
51535   }
51536   jresult = (int)result;
51537   return jresult;
51538 }
51539
51540
51541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
51542   int jresult ;
51543   int result;
51544
51545   {
51546     try {
51547       result = (int)Dali::Toolkit::Visual::Property::SHADER;
51548     } catch (std::out_of_range& e) {
51549       {
51550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51551       };
51552     } catch (std::exception& e) {
51553       {
51554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51555       };
51556     } catch (...) {
51557       {
51558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51559       };
51560     }
51561   }
51562   jresult = (int)result;
51563   return jresult;
51564 }
51565
51566
51567 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
51568   int jresult ;
51569   int result;
51570
51571   {
51572     try {
51573       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
51574     } catch (std::out_of_range& e) {
51575       {
51576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51577       };
51578     } catch (std::exception& e) {
51579       {
51580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51581       };
51582     } catch (...) {
51583       {
51584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51585       };
51586     }
51587   }
51588   jresult = (int)result;
51589   return jresult;
51590 }
51591
51592
51593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
51594   int jresult ;
51595   int result;
51596
51597   {
51598     try {
51599       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
51600     } catch (std::out_of_range& e) {
51601       {
51602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51603       };
51604     } catch (std::exception& e) {
51605       {
51606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51607       };
51608     } catch (...) {
51609       {
51610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51611       };
51612     }
51613   }
51614   jresult = (int)result;
51615   return jresult;
51616 }
51617
51618
51619 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
51620   int jresult ;
51621   int result;
51622
51623   {
51624     try {
51625       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
51626     } catch (std::out_of_range& e) {
51627       {
51628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51629       };
51630     } catch (std::exception& e) {
51631       {
51632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51633       };
51634     } catch (...) {
51635       {
51636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51637       };
51638     }
51639   }
51640   jresult = (int)result;
51641   return jresult;
51642 }
51643
51644
51645 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
51646   int jresult ;
51647   int result;
51648
51649   {
51650     try {
51651       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
51652     } catch (std::out_of_range& e) {
51653       {
51654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51655       };
51656     } catch (std::exception& e) {
51657       {
51658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51659       };
51660     } catch (...) {
51661       {
51662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51663       };
51664     }
51665   }
51666   jresult = (int)result;
51667   return jresult;
51668 }
51669
51670
51671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
51672   int jresult ;
51673   int result;
51674
51675   {
51676     try {
51677       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
51678     } catch (std::out_of_range& e) {
51679       {
51680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51681       };
51682     } catch (std::exception& e) {
51683       {
51684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51685       };
51686     } catch (...) {
51687       {
51688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51689       };
51690     }
51691   }
51692   jresult = (int)result;
51693   return jresult;
51694 }
51695
51696
51697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
51698   int jresult ;
51699   int result;
51700
51701   {
51702     try {
51703       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
51704     } catch (std::out_of_range& e) {
51705       {
51706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51707       };
51708     } catch (std::exception& e) {
51709       {
51710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51711       };
51712     } catch (...) {
51713       {
51714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51715       };
51716     }
51717   }
51718   jresult = (int)result;
51719   return jresult;
51720 }
51721
51722
51723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
51724   int jresult ;
51725   int result;
51726
51727   {
51728     try {
51729       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
51730     } catch (std::out_of_range& e) {
51731       {
51732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51733       };
51734     } catch (std::exception& e) {
51735       {
51736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51737       };
51738     } catch (...) {
51739       {
51740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51741       };
51742     }
51743   }
51744   jresult = (int)result;
51745   return jresult;
51746 }
51747
51748
51749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
51750   int jresult ;
51751   int result;
51752
51753   {
51754     try {
51755       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
51756     } catch (std::out_of_range& e) {
51757       {
51758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51759       };
51760     } catch (std::exception& e) {
51761       {
51762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51763       };
51764     } catch (...) {
51765       {
51766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51767       };
51768     }
51769   }
51770   jresult = (int)result;
51771   return jresult;
51772 }
51773
51774
51775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
51776   int jresult ;
51777   int result;
51778
51779   {
51780     try {
51781       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
51782     } catch (std::out_of_range& e) {
51783       {
51784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51785       };
51786     } catch (std::exception& e) {
51787       {
51788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51789       };
51790     } catch (...) {
51791       {
51792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51793       };
51794     }
51795   }
51796   jresult = (int)result;
51797   return jresult;
51798 }
51799
51800
51801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
51802   int jresult ;
51803   int result;
51804
51805   {
51806     try {
51807       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
51808     } catch (std::out_of_range& e) {
51809       {
51810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51811       };
51812     } catch (std::exception& e) {
51813       {
51814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51815       };
51816     } catch (...) {
51817       {
51818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51819       };
51820     }
51821   }
51822   jresult = (int)result;
51823   return jresult;
51824 }
51825
51826
51827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
51828   int jresult ;
51829   int result;
51830
51831   {
51832     try {
51833       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
51834     } catch (std::out_of_range& e) {
51835       {
51836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51837       };
51838     } catch (std::exception& e) {
51839       {
51840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51841       };
51842     } catch (...) {
51843       {
51844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51845       };
51846     }
51847   }
51848   jresult = (int)result;
51849   return jresult;
51850 }
51851
51852
51853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
51854   int jresult ;
51855   int result;
51856
51857   {
51858     try {
51859       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
51860     } catch (std::out_of_range& e) {
51861       {
51862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51863       };
51864     } catch (std::exception& e) {
51865       {
51866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51867       };
51868     } catch (...) {
51869       {
51870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51871       };
51872     }
51873   }
51874   jresult = (int)result;
51875   return jresult;
51876 }
51877
51878
51879 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
51880   int jresult ;
51881   int result;
51882
51883   {
51884     try {
51885       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
51886     } catch (std::out_of_range& e) {
51887       {
51888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51889       };
51890     } catch (std::exception& e) {
51891       {
51892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51893       };
51894     } catch (...) {
51895       {
51896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51897       };
51898     }
51899   }
51900   jresult = (int)result;
51901   return jresult;
51902 }
51903
51904
51905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
51906   int jresult ;
51907   int result;
51908
51909   {
51910     try {
51911       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
51912     } catch (std::out_of_range& e) {
51913       {
51914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51915       };
51916     } catch (std::exception& e) {
51917       {
51918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51919       };
51920     } catch (...) {
51921       {
51922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51923       };
51924     }
51925   }
51926   jresult = (int)result;
51927   return jresult;
51928 }
51929
51930
51931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
51932   int jresult ;
51933   int result;
51934
51935   {
51936     try {
51937       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
51938     } catch (std::out_of_range& e) {
51939       {
51940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51941       };
51942     } catch (std::exception& e) {
51943       {
51944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51945       };
51946     } catch (...) {
51947       {
51948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51949       };
51950     }
51951   }
51952   jresult = (int)result;
51953   return jresult;
51954 }
51955
51956
51957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
51958   int jresult ;
51959   int result;
51960
51961   {
51962     try {
51963       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
51964     } catch (std::out_of_range& e) {
51965       {
51966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51967       };
51968     } catch (std::exception& e) {
51969       {
51970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51971       };
51972     } catch (...) {
51973       {
51974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51975       };
51976     }
51977   }
51978   jresult = (int)result;
51979   return jresult;
51980 }
51981
51982
51983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
51984   int jresult ;
51985   int result;
51986
51987   {
51988     try {
51989       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
51990     } catch (std::out_of_range& e) {
51991       {
51992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51993       };
51994     } catch (std::exception& e) {
51995       {
51996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51997       };
51998     } catch (...) {
51999       {
52000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52001       };
52002     }
52003   }
52004   jresult = (int)result;
52005   return jresult;
52006 }
52007
52008
52009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
52010   int jresult ;
52011   int result;
52012
52013   {
52014     try {
52015       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
52016     } catch (std::out_of_range& e) {
52017       {
52018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52019       };
52020     } catch (std::exception& e) {
52021       {
52022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52023       };
52024     } catch (...) {
52025       {
52026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52027       };
52028     }
52029   }
52030   jresult = (int)result;
52031   return jresult;
52032 }
52033
52034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
52035   int jresult ;
52036   int result;
52037
52038   {
52039     try {
52040       result = (int)Dali::Toolkit::DevelImageVisual::Property::ALPHA_MASK_URL;
52041     } catch (std::out_of_range& e) {
52042       {
52043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52044       };
52045     } catch (std::exception& e) {
52046       {
52047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52048       };
52049     } catch (...) {
52050       {
52051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52052       };
52053     }
52054   }
52055   jresult = (int)result;
52056   return jresult;
52057 }
52058
52059
52060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
52061   int jresult ;
52062   int result;
52063   {
52064     try
52065     {
52066       result = (int)Dali::Toolkit::DevelImageVisual::Property::BATCH_SIZE;
52067     } catch (std::out_of_range& e) {
52068       {
52069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52070       };
52071     } catch (std::exception& e) {
52072       {
52073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52074       };
52075     } catch (...) {
52076       {
52077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52078       };
52079     }
52080   }
52081   jresult = (int)result;
52082   return jresult;
52083 }
52084
52085 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
52086   int jresult ;
52087   int result;
52088   {
52089     try
52090     {
52091       result = (int)Dali::Toolkit::DevelImageVisual::Property::CACHE_SIZE;
52092     } catch (std::out_of_range& e) {
52093       {
52094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52095       };
52096     } catch (std::exception& e) {
52097       {
52098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52099       };
52100     } catch (...) {
52101       {
52102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52103       };
52104     }
52105   }
52106   jresult = (int)result;
52107   return jresult;
52108 }
52109
52110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
52111   int jresult ;
52112   int result;
52113   {
52114     try
52115     {
52116       result = (int)Dali::Toolkit::DevelImageVisual::Property::FRAME_DELAY;
52117     } catch (std::out_of_range& e) {
52118       {
52119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52120       };
52121     } catch (std::exception& e) {
52122       {
52123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52124       };
52125     } catch (...) {
52126       {
52127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52128       };
52129     }
52130   }
52131   jresult = (int)result;
52132   return jresult;
52133 }
52134
52135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
52136   int jresult ;
52137   int result;
52138   {
52139     try
52140     {
52141       result = (int)Dali::Toolkit::DevelImageVisual::Property::MASK_CONTENT_SCALE;
52142     } catch (std::out_of_range& e) {
52143       {
52144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52145       };
52146     } catch (std::exception& e) {
52147       {
52148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52149       };
52150     } catch (...) {
52151       {
52152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52153       };
52154     }
52155   }
52156   jresult = (int)result;
52157   return jresult;
52158 }
52159
52160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
52161   int jresult ;
52162   int result;
52163   {
52164     try
52165     {
52166       result = (int)Dali::Toolkit::DevelImageVisual::Property::CROP_TO_MASK;
52167     } catch (std::out_of_range& e) {
52168       {
52169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52170       };
52171     } catch (std::exception& e) {
52172       {
52173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52174       };
52175     } catch (...) {
52176       {
52177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52178       };
52179     }
52180   }
52181   jresult = (int)result;
52182   return jresult;
52183 }
52184
52185 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
52186   int jresult ;
52187   int result;
52188
52189   {
52190     try {
52191       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
52192     } catch (std::out_of_range& e) {
52193       {
52194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52195       };
52196     } catch (std::exception& e) {
52197       {
52198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52199       };
52200     } catch (...) {
52201       {
52202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52203       };
52204     }
52205   }
52206   jresult = (int)result;
52207   return jresult;
52208 }
52209
52210
52211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
52212   int jresult ;
52213   int result;
52214
52215   {
52216     try {
52217       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
52218     } catch (std::out_of_range& e) {
52219       {
52220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52221       };
52222     } catch (std::exception& e) {
52223       {
52224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52225       };
52226     } catch (...) {
52227       {
52228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52229       };
52230     }
52231   }
52232   jresult = (int)result;
52233   return jresult;
52234 }
52235
52236
52237 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
52238   int jresult ;
52239   int result;
52240
52241   {
52242     try {
52243       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
52244     } catch (std::out_of_range& e) {
52245       {
52246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52247       };
52248     } catch (std::exception& e) {
52249       {
52250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52251       };
52252     } catch (...) {
52253       {
52254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52255       };
52256     }
52257   }
52258   jresult = (int)result;
52259   return jresult;
52260 }
52261
52262
52263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
52264   int jresult ;
52265   int result;
52266
52267   {
52268     try {
52269       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
52270     } catch (std::out_of_range& e) {
52271       {
52272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52273       };
52274     } catch (std::exception& e) {
52275       {
52276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52277       };
52278     } catch (...) {
52279       {
52280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52281       };
52282     }
52283   }
52284   jresult = (int)result;
52285   return jresult;
52286 }
52287
52288
52289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
52290   int jresult ;
52291   int result;
52292
52293   {
52294     try {
52295       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
52296     } catch (std::out_of_range& e) {
52297       {
52298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52299       };
52300     } catch (std::exception& e) {
52301       {
52302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52303       };
52304     } catch (...) {
52305       {
52306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52307       };
52308     }
52309   }
52310   jresult = (int)result;
52311   return jresult;
52312 }
52313
52314
52315 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
52316   int jresult ;
52317   int result;
52318
52319   {
52320     try {
52321       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
52322     } catch (std::out_of_range& e) {
52323       {
52324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52325       };
52326     } catch (std::exception& e) {
52327       {
52328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52329       };
52330     } catch (...) {
52331       {
52332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52333       };
52334     }
52335   }
52336   jresult = (int)result;
52337   return jresult;
52338 }
52339
52340
52341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
52342   int jresult ;
52343   int result;
52344
52345   {
52346     try {
52347       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
52348     } catch (std::out_of_range& e) {
52349       {
52350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52351       };
52352     } catch (std::exception& e) {
52353       {
52354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52355       };
52356     } catch (...) {
52357       {
52358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52359       };
52360     }
52361   }
52362   jresult = (int)result;
52363   return jresult;
52364 }
52365
52366
52367 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
52368   int jresult ;
52369   int result;
52370
52371   {
52372     try {
52373       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
52374     } catch (std::out_of_range& e) {
52375       {
52376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52377       };
52378     } catch (std::exception& e) {
52379       {
52380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52381       };
52382     } catch (...) {
52383       {
52384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52385       };
52386     }
52387   }
52388   jresult = (int)result;
52389   return jresult;
52390 }
52391
52392
52393 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
52394   int jresult ;
52395   int result;
52396
52397   {
52398     try {
52399       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
52400     } catch (std::out_of_range& e) {
52401       {
52402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52403       };
52404     } catch (std::exception& e) {
52405       {
52406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52407       };
52408     } catch (...) {
52409       {
52410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52411       };
52412     }
52413   }
52414   jresult = (int)result;
52415   return jresult;
52416 }
52417
52418
52419 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
52420   int jresult ;
52421   int result;
52422
52423   {
52424     try {
52425       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
52426     } catch (std::out_of_range& e) {
52427       {
52428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52429       };
52430     } catch (std::exception& e) {
52431       {
52432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52433       };
52434     } catch (...) {
52435       {
52436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52437       };
52438     }
52439   }
52440   jresult = (int)result;
52441   return jresult;
52442 }
52443
52444
52445 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
52446   int jresult ;
52447   int result;
52448
52449   {
52450     try {
52451       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
52452     } catch (std::out_of_range& e) {
52453       {
52454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52455       };
52456     } catch (std::exception& e) {
52457       {
52458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52459       };
52460     } catch (...) {
52461       {
52462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52463       };
52464     }
52465   }
52466   jresult = (int)result;
52467   return jresult;
52468 }
52469
52470
52471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
52472   int jresult ;
52473   int result;
52474
52475   {
52476     try {
52477       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
52478     } catch (std::out_of_range& e) {
52479       {
52480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52481       };
52482     } catch (std::exception& e) {
52483       {
52484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52485       };
52486     } catch (...) {
52487       {
52488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52489       };
52490     }
52491   }
52492   jresult = (int)result;
52493   return jresult;
52494 }
52495
52496
52497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
52498   int jresult ;
52499   int result;
52500
52501   {
52502     try {
52503       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
52504     } catch (std::out_of_range& e) {
52505       {
52506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52507       };
52508     } catch (std::exception& e) {
52509       {
52510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52511       };
52512     } catch (...) {
52513       {
52514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52515       };
52516     }
52517   }
52518   jresult = (int)result;
52519   return jresult;
52520 }
52521
52522
52523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
52524   int jresult ;
52525   int result;
52526
52527   {
52528     try {
52529       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
52530     } catch (std::out_of_range& e) {
52531       {
52532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52533       };
52534     } catch (std::exception& e) {
52535       {
52536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52537       };
52538     } catch (...) {
52539       {
52540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52541       };
52542     }
52543   }
52544   jresult = (int)result;
52545   return jresult;
52546 }
52547
52548
52549 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
52550   int jresult ;
52551   int result;
52552
52553   {
52554     try {
52555       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
52556     } catch (std::out_of_range& e) {
52557       {
52558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52559       };
52560     } catch (std::exception& e) {
52561       {
52562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52563       };
52564     } catch (...) {
52565       {
52566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52567       };
52568     }
52569   }
52570   jresult = (int)result;
52571   return jresult;
52572 }
52573
52574
52575 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
52576   int jresult ;
52577   int result;
52578
52579   {
52580     try {
52581       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
52582     } catch (std::out_of_range& e) {
52583       {
52584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52585       };
52586     } catch (std::exception& e) {
52587       {
52588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52589       };
52590     } catch (...) {
52591       {
52592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52593       };
52594     }
52595   }
52596   jresult = (int)result;
52597   return jresult;
52598 }
52599
52600
52601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
52602   int jresult ;
52603   int result;
52604
52605   {
52606     try {
52607       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
52608     } catch (std::out_of_range& e) {
52609       {
52610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52611       };
52612     } catch (std::exception& e) {
52613       {
52614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52615       };
52616     } catch (...) {
52617       {
52618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52619       };
52620     }
52621   }
52622   jresult = (int)result;
52623   return jresult;
52624 }
52625
52626
52627 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
52628   int jresult ;
52629   int result;
52630
52631   {
52632     try {
52633       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
52634     } catch (std::out_of_range& e) {
52635       {
52636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52637       };
52638     } catch (std::exception& e) {
52639       {
52640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52641       };
52642     } catch (...) {
52643       {
52644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52645       };
52646     }
52647   }
52648   jresult = (int)result;
52649   return jresult;
52650 }
52651
52652
52653 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
52654   int jresult ;
52655   int result;
52656
52657   {
52658     try {
52659       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
52660     } catch (std::out_of_range& e) {
52661       {
52662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52663       };
52664     } catch (std::exception& e) {
52665       {
52666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52667       };
52668     } catch (...) {
52669       {
52670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52671       };
52672     }
52673   }
52674   jresult = (int)result;
52675   return jresult;
52676 }
52677
52678
52679 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
52680   int jresult ;
52681   int result;
52682
52683   {
52684     try {
52685       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
52686     } catch (std::out_of_range& e) {
52687       {
52688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52689       };
52690     } catch (std::exception& e) {
52691       {
52692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52693       };
52694     } catch (...) {
52695       {
52696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52697       };
52698     }
52699   }
52700   jresult = (int)result;
52701   return jresult;
52702 }
52703
52704
52705 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
52706   int jresult ;
52707   int result;
52708
52709   {
52710     try {
52711       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
52712     } catch (std::out_of_range& e) {
52713       {
52714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52715       };
52716     } catch (std::exception& e) {
52717       {
52718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52719       };
52720     } catch (...) {
52721       {
52722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52723       };
52724     }
52725   }
52726   jresult = (int)result;
52727   return jresult;
52728 }
52729
52730
52731 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
52732   int jresult ;
52733   int result;
52734
52735   {
52736     try {
52737       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
52738     } catch (std::out_of_range& e) {
52739       {
52740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52741       };
52742     } catch (std::exception& e) {
52743       {
52744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52745       };
52746     } catch (...) {
52747       {
52748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52749       };
52750     }
52751   }
52752   jresult = (int)result;
52753   return jresult;
52754 }
52755
52756
52757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
52758   int jresult ;
52759   int result;
52760
52761   {
52762     try {
52763       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
52764     } catch (std::out_of_range& e) {
52765       {
52766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52767       };
52768     } catch (std::exception& e) {
52769       {
52770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52771       };
52772     } catch (...) {
52773       {
52774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52775       };
52776     }
52777   }
52778   jresult = (int)result;
52779   return jresult;
52780 }
52781
52782
52783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
52784   int jresult ;
52785   int result;
52786
52787   {
52788     try {
52789       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
52790     } catch (std::out_of_range& e) {
52791       {
52792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52793       };
52794     } catch (std::exception& e) {
52795       {
52796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52797       };
52798     } catch (...) {
52799       {
52800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52801       };
52802     }
52803   }
52804   jresult = (int)result;
52805   return jresult;
52806 }
52807
52808
52809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
52810   int jresult ;
52811   int result;
52812
52813   {
52814     try {
52815       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
52816     } catch (std::out_of_range& e) {
52817       {
52818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52819       };
52820     } catch (std::exception& e) {
52821       {
52822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52823       };
52824     } catch (...) {
52825       {
52826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52827       };
52828     }
52829   }
52830   jresult = (int)result;
52831   return jresult;
52832 }
52833
52834
52835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
52836   int jresult ;
52837   int result;
52838
52839   {
52840     try {
52841       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
52842     } catch (std::out_of_range& e) {
52843       {
52844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52845       };
52846     } catch (std::exception& e) {
52847       {
52848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52849       };
52850     } catch (...) {
52851       {
52852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52853       };
52854     }
52855   }
52856   jresult = (int)result;
52857   return jresult;
52858 }
52859
52860
52861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
52862   int jresult ;
52863   int result;
52864
52865   {
52866     try {
52867       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
52868     } catch (std::out_of_range& e) {
52869       {
52870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52871       };
52872     } catch (std::exception& e) {
52873       {
52874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52875       };
52876     } catch (...) {
52877       {
52878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52879       };
52880     }
52881   }
52882   jresult = (int)result;
52883   return jresult;
52884 }
52885
52886
52887 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
52888   int jresult ;
52889   int result;
52890
52891   {
52892     try {
52893       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
52894     } catch (std::out_of_range& e) {
52895       {
52896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52897       };
52898     } catch (std::exception& e) {
52899       {
52900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52901       };
52902     } catch (...) {
52903       {
52904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52905       };
52906     }
52907   }
52908   jresult = (int)result;
52909   return jresult;
52910 }
52911
52912
52913 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
52914   int jresult ;
52915   int result;
52916
52917   {
52918     try {
52919       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
52920     } catch (std::out_of_range& e) {
52921       {
52922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52923       };
52924     } catch (std::exception& e) {
52925       {
52926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52927       };
52928     } catch (...) {
52929       {
52930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52931       };
52932     }
52933   }
52934   jresult = (int)result;
52935   return jresult;
52936 }
52937
52938
52939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
52940   int jresult ;
52941   int result;
52942
52943   {
52944     try {
52945       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
52946     } catch (std::out_of_range& e) {
52947       {
52948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52949       };
52950     } catch (std::exception& e) {
52951       {
52952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52953       };
52954     } catch (...) {
52955       {
52956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52957       };
52958     }
52959   }
52960   jresult = (int)result;
52961   return jresult;
52962 }
52963
52964
52965 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
52966   int jresult ;
52967   int result;
52968
52969   {
52970     try {
52971       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
52972     } catch (std::out_of_range& e) {
52973       {
52974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52975       };
52976     } catch (std::exception& e) {
52977       {
52978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52979       };
52980     } catch (...) {
52981       {
52982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52983       };
52984     }
52985   }
52986   jresult = (int)result;
52987   return jresult;
52988 }
52989
52990
52991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
52992   int jresult ;
52993   int result;
52994
52995   {
52996     try {
52997       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
52998     } catch (std::out_of_range& e) {
52999       {
53000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53001       };
53002     } catch (std::exception& e) {
53003       {
53004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53005       };
53006     } catch (...) {
53007       {
53008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53009       };
53010     }
53011   }
53012   jresult = (int)result;
53013   return jresult;
53014 }
53015
53016
53017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
53018   int jresult ;
53019   int result;
53020
53021   {
53022     try {
53023       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
53024     } catch (std::out_of_range& e) {
53025       {
53026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53027       };
53028     } catch (std::exception& e) {
53029       {
53030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53031       };
53032     } catch (...) {
53033       {
53034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53035       };
53036     }
53037   }
53038   jresult = (int)result;
53039   return jresult;
53040 }
53041
53042
53043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
53044   int jresult ;
53045   int result;
53046
53047   {
53048     try {
53049       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
53050     } catch (std::out_of_range& e) {
53051       {
53052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53053       };
53054     } catch (std::exception& e) {
53055       {
53056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53057       };
53058     } catch (...) {
53059       {
53060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53061       };
53062     }
53063   }
53064   jresult = (int)result;
53065   return jresult;
53066 }
53067
53068
53069 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
53070   int jresult ;
53071   int result;
53072
53073   {
53074     try {
53075       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
53076     } catch (std::out_of_range& e) {
53077       {
53078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53079       };
53080     } catch (std::exception& e) {
53081       {
53082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53083       };
53084     } catch (...) {
53085       {
53086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53087       };
53088     }
53089   }
53090   jresult = (int)result;
53091   return jresult;
53092 }
53093
53094
53095 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
53096   int jresult ;
53097   int result;
53098
53099   {
53100     try {
53101       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
53102     } catch (std::out_of_range& e) {
53103       {
53104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53105       };
53106     } catch (std::exception& e) {
53107       {
53108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53109       };
53110     } catch (...) {
53111       {
53112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53113       };
53114     }
53115   }
53116   jresult = (int)result;
53117   return jresult;
53118 }
53119
53120
53121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
53122   int jresult ;
53123   int result;
53124
53125   {
53126     try {
53127       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
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 = (int)result;
53143   return jresult;
53144 }
53145
53146
53147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
53148   void * jresult ;
53149   Dali::Toolkit::Builder *result = 0 ;
53150
53151   {
53152     try {
53153       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
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_Builder_New() {
53174   void * jresult ;
53175   Dali::Toolkit::Builder result;
53176
53177   {
53178     try {
53179       result = Dali::Toolkit::Builder::New();
53180     } catch (std::out_of_range& e) {
53181       {
53182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53183       };
53184     } catch (std::exception& e) {
53185       {
53186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53187       };
53188     } catch (...) {
53189       {
53190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53191       };
53192     }
53193   }
53194   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
53195   return jresult;
53196 }
53197
53198
53199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
53200   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53201
53202   arg1 = (Dali::Toolkit::Builder *)jarg1;
53203   {
53204     try {
53205       delete arg1;
53206     } catch (std::out_of_range& e) {
53207       {
53208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53209       };
53210     } catch (std::exception& e) {
53211       {
53212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53213       };
53214     } catch (...) {
53215       {
53216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53217       };
53218     }
53219   }
53220 }
53221
53222
53223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
53224   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53225   std::string *arg2 = 0 ;
53226   Dali::Toolkit::Builder::UIFormat arg3 ;
53227
53228   arg1 = (Dali::Toolkit::Builder *)jarg1;
53229   if (!jarg2) {
53230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53231     return ;
53232   }
53233   std::string arg2_str(jarg2);
53234   arg2 = &arg2_str;
53235   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
53236   {
53237     try {
53238       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
53239     } catch (std::out_of_range& e) {
53240       {
53241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53242       };
53243     } catch (std::exception& e) {
53244       {
53245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53246       };
53247     } catch (...) {
53248       {
53249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53250       };
53251     }
53252   }
53253
53254   //argout typemap for const std::string&
53255
53256 }
53257
53258
53259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
53260   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53261   std::string *arg2 = 0 ;
53262
53263   arg1 = (Dali::Toolkit::Builder *)jarg1;
53264   if (!jarg2) {
53265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53266     return ;
53267   }
53268   std::string arg2_str(jarg2);
53269   arg2 = &arg2_str;
53270   {
53271     try {
53272       (arg1)->LoadFromString((std::string const &)*arg2);
53273     } catch (std::out_of_range& e) {
53274       {
53275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53276       };
53277     } catch (std::exception& e) {
53278       {
53279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53280       };
53281     } catch (...) {
53282       {
53283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53284       };
53285     }
53286   }
53287
53288   //argout typemap for const std::string&
53289
53290 }
53291
53292
53293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
53294   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53295   Dali::Property::Map *arg2 = 0 ;
53296
53297   arg1 = (Dali::Toolkit::Builder *)jarg1;
53298   arg2 = (Dali::Property::Map *)jarg2;
53299   if (!arg2) {
53300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
53301     return ;
53302   }
53303   {
53304     try {
53305       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
53306     } catch (std::out_of_range& e) {
53307       {
53308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53309       };
53310     } catch (std::exception& e) {
53311       {
53312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53313       };
53314     } catch (...) {
53315       {
53316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53317       };
53318     }
53319   }
53320 }
53321
53322
53323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
53324   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53325   std::string *arg2 = 0 ;
53326   Dali::Property::Value *arg3 = 0 ;
53327
53328   arg1 = (Dali::Toolkit::Builder *)jarg1;
53329   if (!jarg2) {
53330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53331     return ;
53332   }
53333   std::string arg2_str(jarg2);
53334   arg2 = &arg2_str;
53335   arg3 = (Dali::Property::Value *)jarg3;
53336   if (!arg3) {
53337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
53338     return ;
53339   }
53340   {
53341     try {
53342       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
53343     } catch (std::out_of_range& e) {
53344       {
53345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53346       };
53347     } catch (std::exception& e) {
53348       {
53349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53350       };
53351     } catch (...) {
53352       {
53353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53354       };
53355     }
53356   }
53357
53358   //argout typemap for const std::string&
53359
53360 }
53361
53362
53363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
53364   void * jresult ;
53365   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53366   Dali::Property::Map *result = 0 ;
53367
53368   arg1 = (Dali::Toolkit::Builder *)jarg1;
53369   {
53370     try {
53371       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
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_Builder_GetConstant(void * jarg1, char * jarg2) {
53392   void * jresult ;
53393   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53394   std::string *arg2 = 0 ;
53395   Dali::Property::Value *result = 0 ;
53396
53397   arg1 = (Dali::Toolkit::Builder *)jarg1;
53398   if (!jarg2) {
53399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53400     return 0;
53401   }
53402   std::string arg2_str(jarg2);
53403   arg2 = &arg2_str;
53404   {
53405     try {
53406       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
53407     } catch (std::out_of_range& e) {
53408       {
53409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53410       };
53411     } catch (std::exception& e) {
53412       {
53413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53414       };
53415     } catch (...) {
53416       {
53417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53418       };
53419     }
53420   }
53421   jresult = (void *)result;
53422
53423   //argout typemap for const std::string&
53424
53425   return jresult;
53426 }
53427
53428
53429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
53430   void * jresult ;
53431   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53432   std::string *arg2 = 0 ;
53433   Dali::Animation result;
53434
53435   arg1 = (Dali::Toolkit::Builder *)jarg1;
53436   if (!jarg2) {
53437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53438     return 0;
53439   }
53440   std::string arg2_str(jarg2);
53441   arg2 = &arg2_str;
53442   {
53443     try {
53444       result = (arg1)->CreateAnimation((std::string const &)*arg2);
53445     } catch (std::out_of_range& e) {
53446       {
53447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53448       };
53449     } catch (std::exception& e) {
53450       {
53451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53452       };
53453     } catch (...) {
53454       {
53455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53456       };
53457     }
53458   }
53459   jresult = new Dali::Animation((const Dali::Animation &)result);
53460
53461   //argout typemap for const std::string&
53462
53463   return jresult;
53464 }
53465
53466
53467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
53468   void * jresult ;
53469   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53470   std::string *arg2 = 0 ;
53471   Dali::Property::Map *arg3 = 0 ;
53472   Dali::Animation result;
53473
53474   arg1 = (Dali::Toolkit::Builder *)jarg1;
53475   if (!jarg2) {
53476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53477     return 0;
53478   }
53479   std::string arg2_str(jarg2);
53480   arg2 = &arg2_str;
53481   arg3 = (Dali::Property::Map *)jarg3;
53482   if (!arg3) {
53483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
53484     return 0;
53485   }
53486   {
53487     try {
53488       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
53489     } catch (std::out_of_range& e) {
53490       {
53491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53492       };
53493     } catch (std::exception& e) {
53494       {
53495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53496       };
53497     } catch (...) {
53498       {
53499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53500       };
53501     }
53502   }
53503   jresult = new Dali::Animation((const Dali::Animation &)result);
53504
53505   //argout typemap for const std::string&
53506
53507   return jresult;
53508 }
53509
53510
53511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
53512   void * jresult ;
53513   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53514   std::string *arg2 = 0 ;
53515   Dali::Actor arg3 ;
53516   Dali::Actor *argp3 ;
53517   Dali::Animation result;
53518
53519   arg1 = (Dali::Toolkit::Builder *)jarg1;
53520   if (!jarg2) {
53521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53522     return 0;
53523   }
53524   std::string arg2_str(jarg2);
53525   arg2 = &arg2_str;
53526   argp3 = (Dali::Actor *)jarg3;
53527   if (!argp3) {
53528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53529     return 0;
53530   }
53531   arg3 = *argp3;
53532   {
53533     try {
53534       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
53535     } catch (std::out_of_range& e) {
53536       {
53537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53538       };
53539     } catch (std::exception& e) {
53540       {
53541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53542       };
53543     } catch (...) {
53544       {
53545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53546       };
53547     }
53548   }
53549   jresult = new Dali::Animation((const Dali::Animation &)result);
53550
53551   //argout typemap for const std::string&
53552
53553   return jresult;
53554 }
53555
53556
53557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
53558   void * jresult ;
53559   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53560   std::string *arg2 = 0 ;
53561   Dali::Property::Map *arg3 = 0 ;
53562   Dali::Actor arg4 ;
53563   Dali::Actor *argp4 ;
53564   Dali::Animation result;
53565
53566   arg1 = (Dali::Toolkit::Builder *)jarg1;
53567   if (!jarg2) {
53568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53569     return 0;
53570   }
53571   std::string arg2_str(jarg2);
53572   arg2 = &arg2_str;
53573   arg3 = (Dali::Property::Map *)jarg3;
53574   if (!arg3) {
53575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
53576     return 0;
53577   }
53578   argp4 = (Dali::Actor *)jarg4;
53579   if (!argp4) {
53580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53581     return 0;
53582   }
53583   arg4 = *argp4;
53584   {
53585     try {
53586       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
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::Animation((const Dali::Animation &)result);
53602
53603   //argout typemap for const std::string&
53604
53605   return jresult;
53606 }
53607
53608
53609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
53610   void * jresult ;
53611   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53612   std::string *arg2 = 0 ;
53613   Dali::BaseHandle result;
53614
53615   arg1 = (Dali::Toolkit::Builder *)jarg1;
53616   if (!jarg2) {
53617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53618     return 0;
53619   }
53620   std::string arg2_str(jarg2);
53621   arg2 = &arg2_str;
53622   {
53623     try {
53624       result = (arg1)->Create((std::string const &)*arg2);
53625     } catch (std::out_of_range& e) {
53626       {
53627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53628       };
53629     } catch (std::exception& e) {
53630       {
53631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53632       };
53633     } catch (...) {
53634       {
53635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53636       };
53637     }
53638   }
53639   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
53640
53641   //argout typemap for const std::string&
53642
53643   return jresult;
53644 }
53645
53646
53647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
53648   void * jresult ;
53649   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53650   std::string *arg2 = 0 ;
53651   Dali::Property::Map *arg3 = 0 ;
53652   Dali::BaseHandle result;
53653
53654   arg1 = (Dali::Toolkit::Builder *)jarg1;
53655   if (!jarg2) {
53656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53657     return 0;
53658   }
53659   std::string arg2_str(jarg2);
53660   arg2 = &arg2_str;
53661   arg3 = (Dali::Property::Map *)jarg3;
53662   if (!arg3) {
53663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
53664     return 0;
53665   }
53666   {
53667     try {
53668       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
53669     } catch (std::out_of_range& e) {
53670       {
53671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53672       };
53673     } catch (std::exception& e) {
53674       {
53675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53676       };
53677     } catch (...) {
53678       {
53679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53680       };
53681     }
53682   }
53683   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
53684
53685   //argout typemap for const std::string&
53686
53687   return jresult;
53688 }
53689
53690
53691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
53692   void * jresult ;
53693   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53694   std::string *arg2 = 0 ;
53695   Dali::BaseHandle result;
53696
53697   arg1 = (Dali::Toolkit::Builder *)jarg1;
53698   if (!jarg2) {
53699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53700     return 0;
53701   }
53702   std::string arg2_str(jarg2);
53703   arg2 = &arg2_str;
53704   {
53705     try {
53706       result = (arg1)->CreateFromJson((std::string const &)*arg2);
53707     } catch (std::out_of_range& e) {
53708       {
53709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53710       };
53711     } catch (std::exception& e) {
53712       {
53713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53714       };
53715     } catch (...) {
53716       {
53717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53718       };
53719     }
53720   }
53721   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
53722
53723   //argout typemap for const std::string&
53724
53725   return jresult;
53726 }
53727
53728
53729 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
53730   unsigned int jresult ;
53731   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53732   std::string *arg2 = 0 ;
53733   Dali::Handle *arg3 = 0 ;
53734   bool result;
53735
53736   arg1 = (Dali::Toolkit::Builder *)jarg1;
53737   if (!jarg2) {
53738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53739     return 0;
53740   }
53741   std::string arg2_str(jarg2);
53742   arg2 = &arg2_str;
53743   arg3 = (Dali::Handle *)jarg3;
53744   if (!arg3) {
53745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
53746     return 0;
53747   }
53748   {
53749     try {
53750       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
53751     } catch (std::out_of_range& e) {
53752       {
53753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53754       };
53755     } catch (std::exception& e) {
53756       {
53757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53758       };
53759     } catch (...) {
53760       {
53761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53762       };
53763     }
53764   }
53765   jresult = result;
53766
53767   //argout typemap for const std::string&
53768
53769   return jresult;
53770 }
53771
53772
53773 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
53774   unsigned int jresult ;
53775   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53776   Dali::Handle *arg2 = 0 ;
53777   std::string *arg3 = 0 ;
53778   bool result;
53779
53780   arg1 = (Dali::Toolkit::Builder *)jarg1;
53781   arg2 = (Dali::Handle *)jarg2;
53782   if (!arg2) {
53783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
53784     return 0;
53785   }
53786   if (!jarg3) {
53787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53788     return 0;
53789   }
53790   std::string arg3_str(jarg3);
53791   arg3 = &arg3_str;
53792   {
53793     try {
53794       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
53795     } catch (std::out_of_range& e) {
53796       {
53797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53798       };
53799     } catch (std::exception& e) {
53800       {
53801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53802       };
53803     } catch (...) {
53804       {
53805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53806       };
53807     }
53808   }
53809   jresult = result;
53810
53811   //argout typemap for const std::string&
53812
53813   return jresult;
53814 }
53815
53816
53817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
53818   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53819   Dali::Actor arg2 ;
53820   Dali::Actor *argp2 ;
53821
53822   arg1 = (Dali::Toolkit::Builder *)jarg1;
53823   argp2 = (Dali::Actor *)jarg2;
53824   if (!argp2) {
53825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53826     return ;
53827   }
53828   arg2 = *argp2;
53829   {
53830     try {
53831       (arg1)->AddActors(arg2);
53832     } catch (std::out_of_range& e) {
53833       {
53834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53835       };
53836     } catch (std::exception& e) {
53837       {
53838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53839       };
53840     } catch (...) {
53841       {
53842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53843       };
53844     }
53845   }
53846 }
53847
53848
53849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
53850   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53851   std::string *arg2 = 0 ;
53852   Dali::Actor arg3 ;
53853   Dali::Actor *argp3 ;
53854
53855   arg1 = (Dali::Toolkit::Builder *)jarg1;
53856   if (!jarg2) {
53857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53858     return ;
53859   }
53860   std::string arg2_str(jarg2);
53861   arg2 = &arg2_str;
53862   argp3 = (Dali::Actor *)jarg3;
53863   if (!argp3) {
53864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53865     return ;
53866   }
53867   arg3 = *argp3;
53868   {
53869     try {
53870       (arg1)->AddActors((std::string const &)*arg2,arg3);
53871     } catch (std::out_of_range& e) {
53872       {
53873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53874       };
53875     } catch (std::exception& e) {
53876       {
53877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53878       };
53879     } catch (...) {
53880       {
53881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53882       };
53883     }
53884   }
53885
53886   //argout typemap for const std::string&
53887
53888 }
53889
53890
53891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
53892   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53893   std::string *arg2 = 0 ;
53894
53895   arg1 = (Dali::Toolkit::Builder *)jarg1;
53896   if (!jarg2) {
53897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53898     return ;
53899   }
53900   std::string arg2_str(jarg2);
53901   arg2 = &arg2_str;
53902   {
53903     try {
53904       (arg1)->CreateRenderTask((std::string const &)*arg2);
53905     } catch (std::out_of_range& e) {
53906       {
53907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53908       };
53909     } catch (std::exception& e) {
53910       {
53911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53912       };
53913     } catch (...) {
53914       {
53915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53916       };
53917     }
53918   }
53919
53920   //argout typemap for const std::string&
53921
53922 }
53923
53924
53925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
53926   void * jresult ;
53927   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53928   std::string *arg2 = 0 ;
53929   Dali::FrameBufferImage result;
53930
53931   arg1 = (Dali::Toolkit::Builder *)jarg1;
53932   if (!jarg2) {
53933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53934     return 0;
53935   }
53936   std::string arg2_str(jarg2);
53937   arg2 = &arg2_str;
53938   {
53939     try {
53940       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
53941     } catch (std::out_of_range& e) {
53942       {
53943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53944       };
53945     } catch (std::exception& e) {
53946       {
53947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53948       };
53949     } catch (...) {
53950       {
53951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53952       };
53953     }
53954   }
53955   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
53956
53957   //argout typemap for const std::string&
53958
53959   return jresult;
53960 }
53961
53962
53963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
53964   void * jresult ;
53965   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53966   std::string *arg2 = 0 ;
53967   Dali::Path result;
53968
53969   arg1 = (Dali::Toolkit::Builder *)jarg1;
53970   if (!jarg2) {
53971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53972     return 0;
53973   }
53974   std::string arg2_str(jarg2);
53975   arg2 = &arg2_str;
53976   {
53977     try {
53978       result = (arg1)->GetPath((std::string const &)*arg2);
53979     } catch (std::out_of_range& e) {
53980       {
53981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53982       };
53983     } catch (std::exception& e) {
53984       {
53985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53986       };
53987     } catch (...) {
53988       {
53989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53990       };
53991     }
53992   }
53993   jresult = new Dali::Path((const Dali::Path &)result);
53994
53995   //argout typemap for const std::string&
53996
53997   return jresult;
53998 }
53999
54000
54001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
54002   void * jresult ;
54003   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
54004   std::string *arg2 = 0 ;
54005   Dali::PathConstrainer result;
54006
54007   arg1 = (Dali::Toolkit::Builder *)jarg1;
54008   if (!jarg2) {
54009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54010     return 0;
54011   }
54012   std::string arg2_str(jarg2);
54013   arg2 = &arg2_str;
54014   {
54015     try {
54016       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
54017     } catch (std::out_of_range& e) {
54018       {
54019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54020       };
54021     } catch (std::exception& e) {
54022       {
54023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54024       };
54025     } catch (...) {
54026       {
54027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54028       };
54029     }
54030   }
54031   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
54032
54033   //argout typemap for const std::string&
54034
54035   return jresult;
54036 }
54037
54038
54039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
54040   void * jresult ;
54041   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
54042   std::string *arg2 = 0 ;
54043   Dali::LinearConstrainer result;
54044
54045   arg1 = (Dali::Toolkit::Builder *)jarg1;
54046   if (!jarg2) {
54047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54048     return 0;
54049   }
54050   std::string arg2_str(jarg2);
54051   arg2 = &arg2_str;
54052   {
54053     try {
54054       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
54055     } catch (std::out_of_range& e) {
54056       {
54057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54058       };
54059     } catch (std::exception& e) {
54060       {
54061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54062       };
54063     } catch (...) {
54064       {
54065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54066       };
54067     }
54068   }
54069   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
54070
54071   //argout typemap for const std::string&
54072
54073   return jresult;
54074 }
54075
54076
54077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
54078   void * jresult ;
54079   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
54080   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
54081
54082   arg1 = (Dali::Toolkit::Builder *)jarg1;
54083   {
54084     try {
54085       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
54086     } catch (std::out_of_range& e) {
54087       {
54088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54089       };
54090     } catch (std::exception& e) {
54091       {
54092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54093       };
54094     } catch (...) {
54095       {
54096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54097       };
54098     }
54099   }
54100   jresult = (void *)result;
54101   return jresult;
54102 }
54103
54104
54105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
54106   void * jresult ;
54107   Dali::Toolkit::TransitionData *result = 0 ;
54108
54109   {
54110     try {
54111       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
54112     } catch (std::out_of_range& e) {
54113       {
54114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54115       };
54116     } catch (std::exception& e) {
54117       {
54118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54119       };
54120     } catch (...) {
54121       {
54122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54123       };
54124     }
54125   }
54126   jresult = (void *)result;
54127   return jresult;
54128 }
54129
54130
54131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
54132   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
54133
54134   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
54135   {
54136     try {
54137       delete arg1;
54138     } catch (std::out_of_range& e) {
54139       {
54140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54141       };
54142     } catch (std::exception& e) {
54143       {
54144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54145       };
54146     } catch (...) {
54147       {
54148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54149       };
54150     }
54151   }
54152 }
54153
54154
54155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
54156   void * jresult ;
54157   Dali::Property::Map *arg1 = 0 ;
54158   Dali::Toolkit::TransitionData result;
54159
54160   arg1 = (Dali::Property::Map *)jarg1;
54161   if (!arg1) {
54162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
54163     return 0;
54164   }
54165   {
54166     try {
54167       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
54168     } catch (std::out_of_range& e) {
54169       {
54170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54171       };
54172     } catch (std::exception& e) {
54173       {
54174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54175       };
54176     } catch (...) {
54177       {
54178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54179       };
54180     }
54181   }
54182   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
54183   return jresult;
54184 }
54185
54186
54187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
54188   void * jresult ;
54189   Dali::Property::Array *arg1 = 0 ;
54190   Dali::Toolkit::TransitionData result;
54191
54192   arg1 = (Dali::Property::Array *)jarg1;
54193   if (!arg1) {
54194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
54195     return 0;
54196   }
54197   {
54198     try {
54199       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
54200     } catch (std::out_of_range& e) {
54201       {
54202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54203       };
54204     } catch (std::exception& e) {
54205       {
54206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54207       };
54208     } catch (...) {
54209       {
54210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54211       };
54212     }
54213   }
54214   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
54215   return jresult;
54216 }
54217
54218
54219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
54220   void * jresult ;
54221   Dali::BaseHandle arg1 ;
54222   Dali::BaseHandle *argp1 ;
54223   Dali::Toolkit::TransitionData result;
54224
54225   argp1 = (Dali::BaseHandle *)jarg1;
54226   if (!argp1) {
54227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54228     return 0;
54229   }
54230   arg1 = *argp1;
54231   {
54232     try {
54233       result = Dali::Toolkit::TransitionData::DownCast(arg1);
54234     } catch (std::out_of_range& e) {
54235       {
54236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54237       };
54238     } catch (std::exception& e) {
54239       {
54240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54241       };
54242     } catch (...) {
54243       {
54244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54245       };
54246     }
54247   }
54248   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
54249   return jresult;
54250 }
54251
54252
54253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
54254   void * jresult ;
54255   Dali::Toolkit::TransitionData *arg1 = 0 ;
54256   Dali::Toolkit::TransitionData *result = 0 ;
54257
54258   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
54259   if (!arg1) {
54260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
54261     return 0;
54262   }
54263   {
54264     try {
54265       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
54266     } catch (std::out_of_range& e) {
54267       {
54268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54269       };
54270     } catch (std::exception& e) {
54271       {
54272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54273       };
54274     } catch (...) {
54275       {
54276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54277       };
54278     }
54279   }
54280   jresult = (void *)result;
54281   return jresult;
54282 }
54283
54284
54285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
54286   void * jresult ;
54287   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
54288   Dali::Toolkit::TransitionData *arg2 = 0 ;
54289   Dali::Toolkit::TransitionData *result = 0 ;
54290
54291   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
54292   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
54293   if (!arg2) {
54294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
54295     return 0;
54296   }
54297   {
54298     try {
54299       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
54300     } catch (std::out_of_range& e) {
54301       {
54302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54303       };
54304     } catch (std::exception& e) {
54305       {
54306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54307       };
54308     } catch (...) {
54309       {
54310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54311       };
54312     }
54313   }
54314   jresult = (void *)result;
54315   return jresult;
54316 }
54317
54318
54319 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
54320   unsigned long jresult ;
54321   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
54322   size_t result;
54323
54324   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
54325   {
54326     try {
54327       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
54328     } catch (std::out_of_range& e) {
54329       {
54330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54331       };
54332     } catch (std::exception& e) {
54333       {
54334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54335       };
54336     } catch (...) {
54337       {
54338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54339       };
54340     }
54341   }
54342   jresult = (unsigned long)result;
54343   return jresult;
54344 }
54345
54346
54347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
54348   void * jresult ;
54349   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
54350   size_t arg2 ;
54351   Dali::Property::Map result;
54352
54353   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
54354   arg2 = (size_t)jarg2;
54355   {
54356     try {
54357       result = (arg1)->GetAnimatorAt(arg2);
54358     } catch (std::out_of_range& e) {
54359       {
54360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54361       };
54362     } catch (std::exception& e) {
54363       {
54364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54365       };
54366     } catch (...) {
54367       {
54368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54369       };
54370     }
54371   }
54372   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
54373   return jresult;
54374 }
54375
54376
54377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_2(void * jarg1) {
54378   void * jresult ;
54379   Dali::Toolkit::Internal::TransitionData *arg1 = (Dali::Toolkit::Internal::TransitionData *) 0 ;
54380   Dali::Toolkit::TransitionData *result = 0 ;
54381
54382   arg1 = (Dali::Toolkit::Internal::TransitionData *)jarg1;
54383   {
54384     try {
54385       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData(arg1);
54386     } catch (std::out_of_range& e) {
54387       {
54388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54389       };
54390     } catch (std::exception& e) {
54391       {
54392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54393       };
54394     } catch (...) {
54395       {
54396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54397       };
54398     }
54399   }
54400   jresult = (void *)result;
54401   return jresult;
54402 }
54403
54404
54405 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
54406   int jresult ;
54407   int result;
54408
54409   {
54410     try {
54411       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
54412     } catch (std::out_of_range& e) {
54413       {
54414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54415       };
54416     } catch (std::exception& e) {
54417       {
54418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54419       };
54420     } catch (...) {
54421       {
54422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54423       };
54424     }
54425   }
54426   jresult = (int)result;
54427   return jresult;
54428 }
54429
54430
54431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
54432   int jresult ;
54433   int result;
54434
54435   {
54436     try {
54437       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
54438     } catch (std::out_of_range& e) {
54439       {
54440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54441       };
54442     } catch (std::exception& e) {
54443       {
54444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54445       };
54446     } catch (...) {
54447       {
54448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54449       };
54450     }
54451   }
54452   jresult = (int)result;
54453   return jresult;
54454 }
54455
54456
54457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
54458   int jresult ;
54459   int result;
54460
54461   {
54462     try {
54463       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
54464     } catch (std::out_of_range& e) {
54465       {
54466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54467       };
54468     } catch (std::exception& e) {
54469       {
54470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54471       };
54472     } catch (...) {
54473       {
54474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54475       };
54476     }
54477   }
54478   jresult = (int)result;
54479   return jresult;
54480 }
54481
54482
54483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
54484   int jresult ;
54485   int result;
54486
54487   {
54488     try {
54489       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
54490     } catch (std::out_of_range& e) {
54491       {
54492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54493       };
54494     } catch (std::exception& e) {
54495       {
54496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54497       };
54498     } catch (...) {
54499       {
54500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54501       };
54502     }
54503   }
54504   jresult = (int)result;
54505   return jresult;
54506 }
54507
54508
54509 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
54510   int jresult ;
54511   int result;
54512
54513   {
54514     try {
54515       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
54516     } catch (std::out_of_range& e) {
54517       {
54518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54519       };
54520     } catch (std::exception& e) {
54521       {
54522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54523       };
54524     } catch (...) {
54525       {
54526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54527       };
54528     }
54529   }
54530   jresult = (int)result;
54531   return jresult;
54532 }
54533
54534
54535 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
54536   int jresult ;
54537   int result;
54538
54539   {
54540     try {
54541       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
54542     } catch (std::out_of_range& e) {
54543       {
54544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54545       };
54546     } catch (std::exception& e) {
54547       {
54548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54549       };
54550     } catch (...) {
54551       {
54552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54553       };
54554     }
54555   }
54556   jresult = (int)result;
54557   return jresult;
54558 }
54559
54560
54561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
54562   int jresult ;
54563   int result;
54564
54565   {
54566     try {
54567       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
54568     } catch (std::out_of_range& e) {
54569       {
54570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54571       };
54572     } catch (std::exception& e) {
54573       {
54574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54575       };
54576     } catch (...) {
54577       {
54578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54579       };
54580     }
54581   }
54582   jresult = (int)result;
54583   return jresult;
54584 }
54585
54586
54587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
54588   int jresult ;
54589   int result;
54590
54591   {
54592     try {
54593       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
54594     } catch (std::out_of_range& e) {
54595       {
54596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54597       };
54598     } catch (std::exception& e) {
54599       {
54600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54601       };
54602     } catch (...) {
54603       {
54604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54605       };
54606     }
54607   }
54608   jresult = (int)result;
54609   return jresult;
54610 }
54611
54612
54613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
54614   int jresult ;
54615   int result;
54616
54617   {
54618     try {
54619       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
54620     } catch (std::out_of_range& e) {
54621       {
54622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54623       };
54624     } catch (std::exception& e) {
54625       {
54626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54627       };
54628     } catch (...) {
54629       {
54630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54631       };
54632     }
54633   }
54634   jresult = (int)result;
54635   return jresult;
54636 }
54637
54638
54639 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
54640   int jresult ;
54641   int result;
54642
54643   {
54644     try {
54645       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
54646     } catch (std::out_of_range& e) {
54647       {
54648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54649       };
54650     } catch (std::exception& e) {
54651       {
54652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54653       };
54654     } catch (...) {
54655       {
54656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54657       };
54658     }
54659   }
54660   jresult = (int)result;
54661   return jresult;
54662 }
54663
54664
54665 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
54666   int jresult ;
54667   int result;
54668
54669   {
54670     try {
54671       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
54672     } catch (std::out_of_range& e) {
54673       {
54674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54675       };
54676     } catch (std::exception& e) {
54677       {
54678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54679       };
54680     } catch (...) {
54681       {
54682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54683       };
54684     }
54685   }
54686   jresult = (int)result;
54687   return jresult;
54688 }
54689
54690
54691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
54692   int jresult ;
54693   int result;
54694
54695   {
54696     try {
54697       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
54698     } catch (std::out_of_range& e) {
54699       {
54700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54701       };
54702     } catch (std::exception& e) {
54703       {
54704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54705       };
54706     } catch (...) {
54707       {
54708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54709       };
54710     }
54711   }
54712   jresult = (int)result;
54713   return jresult;
54714 }
54715
54716
54717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
54718   int jresult ;
54719   int result;
54720
54721   {
54722     try {
54723       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
54724     } catch (std::out_of_range& e) {
54725       {
54726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54727       };
54728     } catch (std::exception& e) {
54729       {
54730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54731       };
54732     } catch (...) {
54733       {
54734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54735       };
54736     }
54737   }
54738   jresult = (int)result;
54739   return jresult;
54740 }
54741
54742
54743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
54744   int jresult ;
54745   int result;
54746
54747   {
54748     try {
54749       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
54750     } catch (std::out_of_range& e) {
54751       {
54752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54753       };
54754     } catch (std::exception& e) {
54755       {
54756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54757       };
54758     } catch (...) {
54759       {
54760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54761       };
54762     }
54763   }
54764   jresult = (int)result;
54765   return jresult;
54766 }
54767
54768
54769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
54770   void * jresult ;
54771   Dali::Toolkit::Control result;
54772
54773   {
54774     try {
54775       result = Dali::Toolkit::Internal::Control::New();
54776     } catch (std::out_of_range& e) {
54777       {
54778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54779       };
54780     } catch (std::exception& e) {
54781       {
54782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54783       };
54784     } catch (...) {
54785       {
54786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54787       };
54788     }
54789   }
54790   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
54791   return jresult;
54792 }
54793
54794
54795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
54796   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
54797   std::string *arg2 = 0 ;
54798
54799   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
54800   if (!jarg2) {
54801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54802     return ;
54803   }
54804   std::string arg2_str(jarg2);
54805   arg2 = &arg2_str;
54806   {
54807     try {
54808       (arg1)->SetStyleName((std::string const &)*arg2);
54809     } catch (std::out_of_range& e) {
54810       {
54811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54812       };
54813     } catch (std::exception& e) {
54814       {
54815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54816       };
54817     } catch (...) {
54818       {
54819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54820       };
54821     }
54822   }
54823
54824   //argout typemap for const std::string&
54825
54826 }
54827
54828
54829 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
54830   char * jresult ;
54831   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
54832   std::string *result = 0 ;
54833
54834   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
54835   {
54836     try {
54837       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
54838     } catch (std::out_of_range& e) {
54839       {
54840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54841       };
54842     } catch (std::exception& e) {
54843       {
54844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54845       };
54846     } catch (...) {
54847       {
54848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54849       };
54850     }
54851   }
54852   jresult = SWIG_csharp_string_callback(result->c_str());
54853   return jresult;
54854 }
54855
54856
54857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
54858   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
54859   Dali::Vector4 *arg2 = 0 ;
54860
54861   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
54862   arg2 = (Dali::Vector4 *)jarg2;
54863   if (!arg2) {
54864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
54865     return ;
54866   }
54867   {
54868     try {
54869       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
54870     } catch (std::out_of_range& e) {
54871       {
54872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54873       };
54874     } catch (std::exception& e) {
54875       {
54876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54877       };
54878     } catch (...) {
54879       {
54880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54881       };
54882     }
54883   }
54884 }
54885
54886
54887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
54888   void * jresult ;
54889   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
54890   Dali::Vector4 result;
54891
54892   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
54893   {
54894     try {
54895       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
54896     } catch (std::out_of_range& e) {
54897       {
54898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54899       };
54900     } catch (std::exception& e) {
54901       {
54902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54903       };
54904     } catch (...) {
54905       {
54906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54907       };
54908     }
54909   }
54910   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
54911   return jresult;
54912 }
54913
54914
54915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
54916   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
54917   Dali::Image arg2 ;
54918   Dali::Image *argp2 ;
54919
54920   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
54921   argp2 = (Dali::Image *)jarg2;
54922   if (!argp2) {
54923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
54924     return ;
54925   }
54926   arg2 = *argp2;
54927   {
54928     try {
54929       (arg1)->SetBackgroundImage(arg2);
54930     } catch (std::out_of_range& e) {
54931       {
54932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54933       };
54934     } catch (std::exception& e) {
54935       {
54936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54937       };
54938     } catch (...) {
54939       {
54940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54941       };
54942     }
54943   }
54944 }
54945
54946
54947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
54948   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
54949   Dali::Property::Map *arg2 = 0 ;
54950
54951   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
54952   arg2 = (Dali::Property::Map *)jarg2;
54953   if (!arg2) {
54954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
54955     return ;
54956   }
54957   {
54958     try {
54959       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
54960     } catch (std::out_of_range& e) {
54961       {
54962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54963       };
54964     } catch (std::exception& e) {
54965       {
54966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54967       };
54968     } catch (...) {
54969       {
54970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54971       };
54972     }
54973   }
54974 }
54975
54976
54977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
54978   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
54979
54980   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
54981   {
54982     try {
54983       (arg1)->ClearBackground();
54984     } catch (std::out_of_range& e) {
54985       {
54986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54987       };
54988     } catch (std::exception& e) {
54989       {
54990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54991       };
54992     } catch (...) {
54993       {
54994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54995       };
54996     }
54997   }
54998 }
54999
55000
55001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
55002   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55003   Dali::Gesture::Type arg2 ;
55004
55005   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55006   arg2 = (Dali::Gesture::Type)jarg2;
55007   {
55008     try {
55009       (arg1)->EnableGestureDetection(arg2);
55010     } catch (std::out_of_range& e) {
55011       {
55012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55013       };
55014     } catch (std::exception& e) {
55015       {
55016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55017       };
55018     } catch (...) {
55019       {
55020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55021       };
55022     }
55023   }
55024 }
55025
55026
55027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
55028   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55029   Dali::Gesture::Type arg2 ;
55030
55031   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55032   arg2 = (Dali::Gesture::Type)jarg2;
55033   {
55034     try {
55035       (arg1)->DisableGestureDetection(arg2);
55036     } catch (std::out_of_range& e) {
55037       {
55038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55039       };
55040     } catch (std::exception& e) {
55041       {
55042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55043       };
55044     } catch (...) {
55045       {
55046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55047       };
55048     }
55049   }
55050 }
55051
55052
55053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
55054   void * jresult ;
55055   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55056   Dali::PinchGestureDetector result;
55057
55058   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55059   {
55060     try {
55061       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
55062     } catch (std::out_of_range& e) {
55063       {
55064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55065       };
55066     } catch (std::exception& e) {
55067       {
55068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55069       };
55070     } catch (...) {
55071       {
55072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55073       };
55074     }
55075   }
55076   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
55077   return jresult;
55078 }
55079
55080
55081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
55082   void * jresult ;
55083   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55084   Dali::PanGestureDetector result;
55085
55086   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55087   {
55088     try {
55089       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
55090     } catch (std::out_of_range& e) {
55091       {
55092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55093       };
55094     } catch (std::exception& e) {
55095       {
55096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55097       };
55098     } catch (...) {
55099       {
55100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55101       };
55102     }
55103   }
55104   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
55105   return jresult;
55106 }
55107
55108
55109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
55110   void * jresult ;
55111   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55112   Dali::TapGestureDetector result;
55113
55114   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55115   {
55116     try {
55117       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
55118     } catch (std::out_of_range& e) {
55119       {
55120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55121       };
55122     } catch (std::exception& e) {
55123       {
55124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55125       };
55126     } catch (...) {
55127       {
55128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55129       };
55130     }
55131   }
55132   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
55133   return jresult;
55134 }
55135
55136
55137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
55138   void * jresult ;
55139   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55140   Dali::LongPressGestureDetector result;
55141
55142   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55143   {
55144     try {
55145       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
55146     } catch (std::out_of_range& e) {
55147       {
55148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55149       };
55150     } catch (std::exception& e) {
55151       {
55152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55153       };
55154     } catch (...) {
55155       {
55156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55157       };
55158     }
55159   }
55160   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
55161   return jresult;
55162 }
55163
55164
55165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
55166   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55167   bool arg2 ;
55168
55169   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55170   arg2 = jarg2 ? true : false;
55171   {
55172     try {
55173       (arg1)->SetKeyboardNavigationSupport(arg2);
55174     } catch (std::out_of_range& e) {
55175       {
55176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55177       };
55178     } catch (std::exception& e) {
55179       {
55180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55181       };
55182     } catch (...) {
55183       {
55184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55185       };
55186     }
55187   }
55188 }
55189
55190
55191 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
55192   unsigned int jresult ;
55193   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55194   bool result;
55195
55196   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55197   {
55198     try {
55199       result = (bool)(arg1)->IsKeyboardNavigationSupported();
55200     } catch (std::out_of_range& e) {
55201       {
55202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55203       };
55204     } catch (std::exception& e) {
55205       {
55206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55207       };
55208     } catch (...) {
55209       {
55210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55211       };
55212     }
55213   }
55214   jresult = result;
55215   return jresult;
55216 }
55217
55218
55219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
55220   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55221
55222   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55223   {
55224     try {
55225       (arg1)->SetKeyInputFocus();
55226     } catch (std::out_of_range& e) {
55227       {
55228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55229       };
55230     } catch (std::exception& e) {
55231       {
55232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55233       };
55234     } catch (...) {
55235       {
55236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55237       };
55238     }
55239   }
55240 }
55241
55242
55243 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
55244   unsigned int jresult ;
55245   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55246   bool result;
55247
55248   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55249   {
55250     try {
55251       result = (bool)(arg1)->HasKeyInputFocus();
55252     } catch (std::out_of_range& e) {
55253       {
55254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55255       };
55256     } catch (std::exception& e) {
55257       {
55258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55259       };
55260     } catch (...) {
55261       {
55262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55263       };
55264     }
55265   }
55266   jresult = result;
55267   return jresult;
55268 }
55269
55270
55271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
55272   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55273
55274   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55275   {
55276     try {
55277       (arg1)->ClearKeyInputFocus();
55278     } catch (std::out_of_range& e) {
55279       {
55280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55281       };
55282     } catch (std::exception& e) {
55283       {
55284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55285       };
55286     } catch (...) {
55287       {
55288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55289       };
55290     }
55291   }
55292 }
55293
55294
55295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
55296   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55297   bool arg2 ;
55298
55299   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55300   arg2 = jarg2 ? true : false;
55301   {
55302     try {
55303       (arg1)->SetAsKeyboardFocusGroup(arg2);
55304     } catch (std::out_of_range& e) {
55305       {
55306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55307       };
55308     } catch (std::exception& e) {
55309       {
55310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55311       };
55312     } catch (...) {
55313       {
55314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55315       };
55316     }
55317   }
55318 }
55319
55320
55321 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
55322   unsigned int jresult ;
55323   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55324   bool result;
55325
55326   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55327   {
55328     try {
55329       result = (bool)(arg1)->IsKeyboardFocusGroup();
55330     } catch (std::out_of_range& e) {
55331       {
55332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55333       };
55334     } catch (std::exception& e) {
55335       {
55336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55337       };
55338     } catch (...) {
55339       {
55340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55341       };
55342     }
55343   }
55344   jresult = result;
55345   return jresult;
55346 }
55347
55348
55349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_AccessibilityActivate(void * jarg1) {
55350   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55351
55352   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55353   {
55354     try {
55355       (arg1)->AccessibilityActivate();
55356     } catch (std::out_of_range& e) {
55357       {
55358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55359       };
55360     } catch (std::exception& e) {
55361       {
55362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55363       };
55364     } catch (...) {
55365       {
55366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55367       };
55368     }
55369   }
55370 }
55371
55372
55373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_KeyboardEnter(void * jarg1) {
55374   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55375
55376   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55377   {
55378     try {
55379       (arg1)->KeyboardEnter();
55380     } catch (std::out_of_range& e) {
55381       {
55382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55383       };
55384     } catch (std::exception& e) {
55385       {
55386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55387       };
55388     } catch (...) {
55389       {
55390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55391       };
55392     }
55393   }
55394 }
55395
55396
55397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
55398   void * jresult ;
55399   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55400   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
55401
55402   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55403   {
55404     try {
55405       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
55406     } catch (std::out_of_range& e) {
55407       {
55408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55409       };
55410     } catch (std::exception& e) {
55411       {
55412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55413       };
55414     } catch (...) {
55415       {
55416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55417       };
55418     }
55419   }
55420   jresult = (void *)result;
55421   return jresult;
55422 }
55423
55424
55425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
55426   void * jresult ;
55427   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55428   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
55429
55430   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55431   {
55432     try {
55433       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
55434     } catch (std::out_of_range& e) {
55435       {
55436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55437       };
55438     } catch (std::exception& e) {
55439       {
55440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55441       };
55442     } catch (...) {
55443       {
55444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55445       };
55446     }
55447   }
55448   jresult = (void *)result;
55449   return jresult;
55450 }
55451
55452
55453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
55454   void * jresult ;
55455   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55456   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
55457
55458   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55459   {
55460     try {
55461       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
55462     } catch (std::out_of_range& e) {
55463       {
55464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55465       };
55466     } catch (std::exception& e) {
55467       {
55468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55469       };
55470     } catch (...) {
55471       {
55472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55473       };
55474     }
55475   }
55476   jresult = (void *)result;
55477   return jresult;
55478 }
55479
55480
55481 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_EmitKeyEventSignal(void * jarg1, void * jarg2) {
55482   unsigned int jresult ;
55483   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55484   Dali::KeyEvent *arg2 = 0 ;
55485   bool result;
55486
55487   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55488   arg2 = (Dali::KeyEvent *)jarg2;
55489   if (!arg2) {
55490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
55491     return 0;
55492   }
55493   {
55494     try {
55495       result = (bool)(arg1)->EmitKeyEventSignal((Dali::KeyEvent const &)*arg2);
55496     } catch (std::out_of_range& e) {
55497       {
55498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55499       };
55500     } catch (std::exception& e) {
55501       {
55502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55503       };
55504     } catch (...) {
55505       {
55506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55507       };
55508     }
55509   }
55510   jresult = result;
55511   return jresult;
55512 }
55513
55514
55515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
55516   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55517   int arg2 ;
55518   SwigDirector_ViewImpl *darg = 0;
55519
55520   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55521   arg2 = (int)jarg2;
55522   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55523   {
55524     try {
55525       (darg)->OnStageConnection(arg2);
55526     } catch (std::out_of_range& e) {
55527       {
55528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55529       };
55530     } catch (std::exception& e) {
55531       {
55532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55533       };
55534     } catch (...) {
55535       {
55536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55537       };
55538     }
55539   }
55540 }
55541
55542
55543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
55544   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55545   int arg2 ;
55546   SwigDirector_ViewImpl *darg = 0;
55547
55548   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55549   arg2 = (int)jarg2;
55550   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55551   {
55552     try {
55553       (darg)->OnStageConnectionSwigPublic(arg2);
55554     } catch (std::out_of_range& e) {
55555       {
55556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55557       };
55558     } catch (std::exception& e) {
55559       {
55560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55561       };
55562     } catch (...) {
55563       {
55564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55565       };
55566     }
55567   }
55568 }
55569
55570
55571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
55572   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55573   SwigDirector_ViewImpl *darg = 0;
55574
55575   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55576   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55577   {
55578     try {
55579       (darg)->OnStageDisconnection();
55580     } catch (std::out_of_range& e) {
55581       {
55582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55583       };
55584     } catch (std::exception& e) {
55585       {
55586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55587       };
55588     } catch (...) {
55589       {
55590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55591       };
55592     }
55593   }
55594 }
55595
55596
55597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
55598   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55599   SwigDirector_ViewImpl *darg = 0;
55600
55601   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55602   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55603   {
55604     try {
55605       (darg)->OnStageDisconnectionSwigPublic();
55606     } catch (std::out_of_range& e) {
55607       {
55608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55609       };
55610     } catch (std::exception& e) {
55611       {
55612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55613       };
55614     } catch (...) {
55615       {
55616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55617       };
55618     }
55619   }
55620 }
55621
55622
55623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
55624   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55625   Dali::Actor *arg2 = 0 ;
55626   SwigDirector_ViewImpl *darg = 0;
55627
55628   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55629   arg2 = (Dali::Actor *)jarg2;
55630   if (!arg2) {
55631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
55632     return ;
55633   }
55634   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55635   {
55636     try {
55637       (darg)->OnChildAdd(*arg2);
55638     } catch (std::out_of_range& e) {
55639       {
55640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55641       };
55642     } catch (std::exception& e) {
55643       {
55644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55645       };
55646     } catch (...) {
55647       {
55648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55649       };
55650     }
55651   }
55652 }
55653
55654
55655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
55656   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55657   Dali::Actor *arg2 = 0 ;
55658   SwigDirector_ViewImpl *darg = 0;
55659
55660   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55661   arg2 = (Dali::Actor *)jarg2;
55662   if (!arg2) {
55663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
55664     return ;
55665   }
55666   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55667   {
55668     try {
55669       (darg)->OnChildAddSwigPublic(*arg2);
55670     } catch (std::out_of_range& e) {
55671       {
55672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55673       };
55674     } catch (std::exception& e) {
55675       {
55676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55677       };
55678     } catch (...) {
55679       {
55680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55681       };
55682     }
55683   }
55684 }
55685
55686
55687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
55688   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55689   Dali::Actor *arg2 = 0 ;
55690   SwigDirector_ViewImpl *darg = 0;
55691
55692   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55693   arg2 = (Dali::Actor *)jarg2;
55694   if (!arg2) {
55695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
55696     return ;
55697   }
55698   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55699   {
55700     try {
55701       (darg)->OnChildRemove(*arg2);
55702     } catch (std::out_of_range& e) {
55703       {
55704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55705       };
55706     } catch (std::exception& e) {
55707       {
55708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55709       };
55710     } catch (...) {
55711       {
55712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55713       };
55714     }
55715   }
55716 }
55717
55718
55719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
55720   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55721   Dali::Actor *arg2 = 0 ;
55722   SwigDirector_ViewImpl *darg = 0;
55723
55724   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55725   arg2 = (Dali::Actor *)jarg2;
55726   if (!arg2) {
55727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
55728     return ;
55729   }
55730   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55731   {
55732     try {
55733       (darg)->OnChildRemoveSwigPublic(*arg2);
55734     } catch (std::out_of_range& e) {
55735       {
55736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55737       };
55738     } catch (std::exception& e) {
55739       {
55740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55741       };
55742     } catch (...) {
55743       {
55744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55745       };
55746     }
55747   }
55748 }
55749
55750
55751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
55752   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55753   Dali::Property::Index arg2 ;
55754   Dali::Property::Value arg3 ;
55755   Dali::Property::Value *argp3 ;
55756   SwigDirector_ViewImpl *darg = 0;
55757
55758   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55759   arg2 = (Dali::Property::Index)jarg2;
55760   argp3 = (Dali::Property::Value *)jarg3;
55761   if (!argp3) {
55762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
55763     return ;
55764   }
55765   arg3 = *argp3;
55766   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55767   {
55768     try {
55769       (darg)->OnPropertySet(arg2,arg3);
55770     } catch (std::out_of_range& e) {
55771       {
55772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55773       };
55774     } catch (std::exception& e) {
55775       {
55776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55777       };
55778     } catch (...) {
55779       {
55780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55781       };
55782     }
55783   }
55784 }
55785
55786
55787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
55788   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55789   Dali::Property::Index arg2 ;
55790   Dali::Property::Value arg3 ;
55791   Dali::Property::Value *argp3 ;
55792   SwigDirector_ViewImpl *darg = 0;
55793
55794   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55795   arg2 = (Dali::Property::Index)jarg2;
55796   argp3 = (Dali::Property::Value *)jarg3;
55797   if (!argp3) {
55798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
55799     return ;
55800   }
55801   arg3 = *argp3;
55802   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55803   {
55804     try {
55805       (darg)->OnPropertySetSwigPublic(arg2,arg3);
55806     } catch (std::out_of_range& e) {
55807       {
55808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55809       };
55810     } catch (std::exception& e) {
55811       {
55812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55813       };
55814     } catch (...) {
55815       {
55816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55817       };
55818     }
55819   }
55820 }
55821
55822
55823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
55824   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55825   Dali::Vector3 *arg2 = 0 ;
55826   SwigDirector_ViewImpl *darg = 0;
55827
55828   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55829   arg2 = (Dali::Vector3 *)jarg2;
55830   if (!arg2) {
55831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
55832     return ;
55833   }
55834   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55835   {
55836     try {
55837       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
55838     } catch (std::out_of_range& e) {
55839       {
55840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55841       };
55842     } catch (std::exception& e) {
55843       {
55844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55845       };
55846     } catch (...) {
55847       {
55848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55849       };
55850     }
55851   }
55852 }
55853
55854
55855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
55856   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55857   Dali::Vector3 *arg2 = 0 ;
55858   SwigDirector_ViewImpl *darg = 0;
55859
55860   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55861   arg2 = (Dali::Vector3 *)jarg2;
55862   if (!arg2) {
55863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
55864     return ;
55865   }
55866   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55867   {
55868     try {
55869       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
55870     } catch (std::out_of_range& e) {
55871       {
55872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55873       };
55874     } catch (std::exception& e) {
55875       {
55876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55877       };
55878     } catch (...) {
55879       {
55880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55881       };
55882     }
55883   }
55884 }
55885
55886
55887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
55888   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55889   Dali::Animation *arg2 = 0 ;
55890   Dali::Vector3 *arg3 = 0 ;
55891   SwigDirector_ViewImpl *darg = 0;
55892
55893   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55894   arg2 = (Dali::Animation *)jarg2;
55895   if (!arg2) {
55896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
55897     return ;
55898   }
55899   arg3 = (Dali::Vector3 *)jarg3;
55900   if (!arg3) {
55901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
55902     return ;
55903   }
55904   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55905   {
55906     try {
55907       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
55908     } catch (std::out_of_range& e) {
55909       {
55910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55911       };
55912     } catch (std::exception& e) {
55913       {
55914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55915       };
55916     } catch (...) {
55917       {
55918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55919       };
55920     }
55921   }
55922 }
55923
55924
55925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
55926   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55927   Dali::Animation *arg2 = 0 ;
55928   Dali::Vector3 *arg3 = 0 ;
55929   SwigDirector_ViewImpl *darg = 0;
55930
55931   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55932   arg2 = (Dali::Animation *)jarg2;
55933   if (!arg2) {
55934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
55935     return ;
55936   }
55937   arg3 = (Dali::Vector3 *)jarg3;
55938   if (!arg3) {
55939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
55940     return ;
55941   }
55942   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55943   {
55944     try {
55945       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
55946     } catch (std::out_of_range& e) {
55947       {
55948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55949       };
55950     } catch (std::exception& e) {
55951       {
55952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55953       };
55954     } catch (...) {
55955       {
55956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55957       };
55958     }
55959   }
55960 }
55961
55962
55963 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
55964   unsigned int jresult ;
55965   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55966   Dali::TouchEvent *arg2 = 0 ;
55967   SwigDirector_ViewImpl *darg = 0;
55968   bool result;
55969
55970   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55971   arg2 = (Dali::TouchEvent *)jarg2;
55972   if (!arg2) {
55973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
55974     return 0;
55975   }
55976   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55977   {
55978     try {
55979       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
55980     } catch (std::out_of_range& e) {
55981       {
55982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55983       };
55984     } catch (std::exception& e) {
55985       {
55986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55987       };
55988     } catch (...) {
55989       {
55990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55991       };
55992     }
55993   }
55994   jresult = result;
55995   return jresult;
55996 }
55997
55998
55999 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
56000   unsigned int jresult ;
56001   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56002   Dali::TouchEvent *arg2 = 0 ;
56003   SwigDirector_ViewImpl *darg = 0;
56004   bool result;
56005
56006   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56007   arg2 = (Dali::TouchEvent *)jarg2;
56008   if (!arg2) {
56009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
56010     return 0;
56011   }
56012   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56013   {
56014     try {
56015       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
56016     } catch (std::out_of_range& e) {
56017       {
56018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56019       };
56020     } catch (std::exception& e) {
56021       {
56022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56023       };
56024     } catch (...) {
56025       {
56026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56027       };
56028     }
56029   }
56030   jresult = result;
56031   return jresult;
56032 }
56033
56034
56035 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
56036   unsigned int jresult ;
56037   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56038   Dali::HoverEvent *arg2 = 0 ;
56039   SwigDirector_ViewImpl *darg = 0;
56040   bool result;
56041
56042   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56043   arg2 = (Dali::HoverEvent *)jarg2;
56044   if (!arg2) {
56045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
56046     return 0;
56047   }
56048   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56049   {
56050     try {
56051       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
56052     } catch (std::out_of_range& e) {
56053       {
56054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56055       };
56056     } catch (std::exception& e) {
56057       {
56058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56059       };
56060     } catch (...) {
56061       {
56062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56063       };
56064     }
56065   }
56066   jresult = result;
56067   return jresult;
56068 }
56069
56070
56071 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
56072   unsigned int jresult ;
56073   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56074   Dali::HoverEvent *arg2 = 0 ;
56075   SwigDirector_ViewImpl *darg = 0;
56076   bool result;
56077
56078   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56079   arg2 = (Dali::HoverEvent *)jarg2;
56080   if (!arg2) {
56081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
56082     return 0;
56083   }
56084   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56085   {
56086     try {
56087       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
56088     } catch (std::out_of_range& e) {
56089       {
56090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56091       };
56092     } catch (std::exception& e) {
56093       {
56094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56095       };
56096     } catch (...) {
56097       {
56098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56099       };
56100     }
56101   }
56102   jresult = result;
56103   return jresult;
56104 }
56105
56106
56107 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
56108   unsigned int jresult ;
56109   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56110   Dali::KeyEvent *arg2 = 0 ;
56111   SwigDirector_ViewImpl *darg = 0;
56112   bool result;
56113
56114   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56115   arg2 = (Dali::KeyEvent *)jarg2;
56116   if (!arg2) {
56117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56118     return 0;
56119   }
56120   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56121   {
56122     try {
56123       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
56124     } catch (std::out_of_range& e) {
56125       {
56126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56127       };
56128     } catch (std::exception& e) {
56129       {
56130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56131       };
56132     } catch (...) {
56133       {
56134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56135       };
56136     }
56137   }
56138   jresult = result;
56139   return jresult;
56140 }
56141
56142
56143 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
56144   unsigned int jresult ;
56145   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56146   Dali::KeyEvent *arg2 = 0 ;
56147   SwigDirector_ViewImpl *darg = 0;
56148   bool result;
56149
56150   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56151   arg2 = (Dali::KeyEvent *)jarg2;
56152   if (!arg2) {
56153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56154     return 0;
56155   }
56156   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56157   {
56158     try {
56159       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
56160     } catch (std::out_of_range& e) {
56161       {
56162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56163       };
56164     } catch (std::exception& e) {
56165       {
56166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56167       };
56168     } catch (...) {
56169       {
56170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56171       };
56172     }
56173   }
56174   jresult = result;
56175   return jresult;
56176 }
56177
56178
56179 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
56180   unsigned int jresult ;
56181   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56182   Dali::WheelEvent *arg2 = 0 ;
56183   SwigDirector_ViewImpl *darg = 0;
56184   bool result;
56185
56186   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56187   arg2 = (Dali::WheelEvent *)jarg2;
56188   if (!arg2) {
56189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56190     return 0;
56191   }
56192   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56193   {
56194     try {
56195       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
56196     } catch (std::out_of_range& e) {
56197       {
56198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56199       };
56200     } catch (std::exception& e) {
56201       {
56202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56203       };
56204     } catch (...) {
56205       {
56206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56207       };
56208     }
56209   }
56210   jresult = result;
56211   return jresult;
56212 }
56213
56214
56215 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
56216   unsigned int jresult ;
56217   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56218   Dali::WheelEvent *arg2 = 0 ;
56219   SwigDirector_ViewImpl *darg = 0;
56220   bool result;
56221
56222   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56223   arg2 = (Dali::WheelEvent *)jarg2;
56224   if (!arg2) {
56225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56226     return 0;
56227   }
56228   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56229   {
56230     try {
56231       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
56232     } catch (std::out_of_range& e) {
56233       {
56234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56235       };
56236     } catch (std::exception& e) {
56237       {
56238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56239       };
56240     } catch (...) {
56241       {
56242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56243       };
56244     }
56245   }
56246   jresult = result;
56247   return jresult;
56248 }
56249
56250
56251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
56252   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56253   Dali::Vector2 *arg2 = 0 ;
56254   Dali::RelayoutContainer *arg3 = 0 ;
56255   SwigDirector_ViewImpl *darg = 0;
56256
56257   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56258   arg2 = (Dali::Vector2 *)jarg2;
56259   if (!arg2) {
56260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
56261     return ;
56262   }
56263   arg3 = (Dali::RelayoutContainer *)jarg3;
56264   if (!arg3) {
56265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
56266     return ;
56267   }
56268   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56269   {
56270     try {
56271       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
56272     } catch (std::out_of_range& e) {
56273       {
56274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56275       };
56276     } catch (std::exception& e) {
56277       {
56278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56279       };
56280     } catch (...) {
56281       {
56282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56283       };
56284     }
56285   }
56286 }
56287
56288
56289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
56290   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56291   Dali::Vector2 *arg2 = 0 ;
56292   Dali::RelayoutContainer *arg3 = 0 ;
56293   SwigDirector_ViewImpl *darg = 0;
56294
56295   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56296   arg2 = (Dali::Vector2 *)jarg2;
56297   if (!arg2) {
56298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
56299     return ;
56300   }
56301   arg3 = (Dali::RelayoutContainer *)jarg3;
56302   if (!arg3) {
56303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
56304     return ;
56305   }
56306   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56307   {
56308     try {
56309       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
56310     } catch (std::out_of_range& e) {
56311       {
56312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56313       };
56314     } catch (std::exception& e) {
56315       {
56316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56317       };
56318     } catch (...) {
56319       {
56320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56321       };
56322     }
56323   }
56324 }
56325
56326
56327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
56328   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56329   Dali::ResizePolicy::Type arg2 ;
56330   Dali::Dimension::Type arg3 ;
56331   SwigDirector_ViewImpl *darg = 0;
56332
56333   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56334   arg2 = (Dali::ResizePolicy::Type)jarg2;
56335   arg3 = (Dali::Dimension::Type)jarg3;
56336   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56337   {
56338     try {
56339       (darg)->OnSetResizePolicy(arg2,arg3);
56340     } catch (std::out_of_range& e) {
56341       {
56342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56343       };
56344     } catch (std::exception& e) {
56345       {
56346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56347       };
56348     } catch (...) {
56349       {
56350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56351       };
56352     }
56353   }
56354 }
56355
56356
56357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
56358   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56359   Dali::ResizePolicy::Type arg2 ;
56360   Dali::Dimension::Type arg3 ;
56361   SwigDirector_ViewImpl *darg = 0;
56362
56363   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56364   arg2 = (Dali::ResizePolicy::Type)jarg2;
56365   arg3 = (Dali::Dimension::Type)jarg3;
56366   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56367   {
56368     try {
56369       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
56370     } catch (std::out_of_range& e) {
56371       {
56372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56373       };
56374     } catch (std::exception& e) {
56375       {
56376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56377       };
56378     } catch (...) {
56379       {
56380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56381       };
56382     }
56383   }
56384 }
56385
56386
56387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
56388   void * jresult ;
56389   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56390   SwigDirector_ViewImpl *darg = 0;
56391   Dali::Vector3 result;
56392
56393   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56394   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56395   {
56396     try {
56397       result = (darg)->GetNaturalSize();
56398     } catch (std::out_of_range& e) {
56399       {
56400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56401       };
56402     } catch (std::exception& e) {
56403       {
56404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56405       };
56406     } catch (...) {
56407       {
56408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56409       };
56410     }
56411   }
56412   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
56413   return jresult;
56414 }
56415
56416
56417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
56418   void * jresult ;
56419   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56420   SwigDirector_ViewImpl *darg = 0;
56421   Dali::Vector3 result;
56422
56423   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56424   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56425   {
56426     try {
56427       result = (darg)->GetNaturalSizeSwigPublic();
56428     } catch (std::out_of_range& e) {
56429       {
56430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56431       };
56432     } catch (std::exception& e) {
56433       {
56434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56435       };
56436     } catch (...) {
56437       {
56438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56439       };
56440     }
56441   }
56442   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
56443   return jresult;
56444 }
56445
56446
56447 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
56448   float jresult ;
56449   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56450   Dali::Actor *arg2 = 0 ;
56451   Dali::Dimension::Type arg3 ;
56452   SwigDirector_ViewImpl *darg = 0;
56453   float result;
56454
56455   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56456   arg2 = (Dali::Actor *)jarg2;
56457   if (!arg2) {
56458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
56459     return 0;
56460   }
56461   arg3 = (Dali::Dimension::Type)jarg3;
56462   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56463   {
56464     try {
56465       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
56466     } catch (std::out_of_range& e) {
56467       {
56468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56469       };
56470     } catch (std::exception& e) {
56471       {
56472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56473       };
56474     } catch (...) {
56475       {
56476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56477       };
56478     }
56479   }
56480   jresult = result;
56481   return jresult;
56482 }
56483
56484
56485 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
56486   float jresult ;
56487   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56488   Dali::Actor *arg2 = 0 ;
56489   Dali::Dimension::Type arg3 ;
56490   SwigDirector_ViewImpl *darg = 0;
56491   float result;
56492
56493   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56494   arg2 = (Dali::Actor *)jarg2;
56495   if (!arg2) {
56496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
56497     return 0;
56498   }
56499   arg3 = (Dali::Dimension::Type)jarg3;
56500   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56501   {
56502     try {
56503       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
56504     } catch (std::out_of_range& e) {
56505       {
56506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56507       };
56508     } catch (std::exception& e) {
56509       {
56510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56511       };
56512     } catch (...) {
56513       {
56514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56515       };
56516     }
56517   }
56518   jresult = result;
56519   return jresult;
56520 }
56521
56522
56523 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
56524   float jresult ;
56525   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56526   float arg2 ;
56527   SwigDirector_ViewImpl *darg = 0;
56528   float result;
56529
56530   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56531   arg2 = (float)jarg2;
56532   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56533   {
56534     try {
56535       result = (float)(darg)->GetHeightForWidth(arg2);
56536     } catch (std::out_of_range& e) {
56537       {
56538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56539       };
56540     } catch (std::exception& e) {
56541       {
56542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56543       };
56544     } catch (...) {
56545       {
56546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56547       };
56548     }
56549   }
56550   jresult = result;
56551   return jresult;
56552 }
56553
56554
56555 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
56556   float jresult ;
56557   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56558   float arg2 ;
56559   SwigDirector_ViewImpl *darg = 0;
56560   float result;
56561
56562   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56563   arg2 = (float)jarg2;
56564   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56565   {
56566     try {
56567       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
56568     } catch (std::out_of_range& e) {
56569       {
56570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56571       };
56572     } catch (std::exception& e) {
56573       {
56574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56575       };
56576     } catch (...) {
56577       {
56578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56579       };
56580     }
56581   }
56582   jresult = result;
56583   return jresult;
56584 }
56585
56586
56587 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
56588   float jresult ;
56589   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56590   float arg2 ;
56591   SwigDirector_ViewImpl *darg = 0;
56592   float result;
56593
56594   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56595   arg2 = (float)jarg2;
56596   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56597   {
56598     try {
56599       result = (float)(darg)->GetWidthForHeight(arg2);
56600     } catch (std::out_of_range& e) {
56601       {
56602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56603       };
56604     } catch (std::exception& e) {
56605       {
56606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56607       };
56608     } catch (...) {
56609       {
56610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56611       };
56612     }
56613   }
56614   jresult = result;
56615   return jresult;
56616 }
56617
56618
56619 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
56620   float jresult ;
56621   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56622   float arg2 ;
56623   SwigDirector_ViewImpl *darg = 0;
56624   float result;
56625
56626   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56627   arg2 = (float)jarg2;
56628   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56629   {
56630     try {
56631       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
56632     } catch (std::out_of_range& e) {
56633       {
56634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56635       };
56636     } catch (std::exception& e) {
56637       {
56638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56639       };
56640     } catch (...) {
56641       {
56642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56643       };
56644     }
56645   }
56646   jresult = result;
56647   return jresult;
56648 }
56649
56650
56651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
56652   unsigned int jresult ;
56653   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56654   Dali::Dimension::Type arg2 ;
56655   SwigDirector_ViewImpl *darg = 0;
56656   bool result;
56657
56658   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56659   arg2 = (Dali::Dimension::Type)jarg2;
56660   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56661   {
56662     try {
56663       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
56664     } catch (std::out_of_range& e) {
56665       {
56666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56667       };
56668     } catch (std::exception& e) {
56669       {
56670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56671       };
56672     } catch (...) {
56673       {
56674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56675       };
56676     }
56677   }
56678   jresult = result;
56679   return jresult;
56680 }
56681
56682
56683 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
56684   unsigned int jresult ;
56685   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56686   Dali::Dimension::Type arg2 ;
56687   SwigDirector_ViewImpl *darg = 0;
56688   bool result;
56689
56690   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56691   arg2 = (Dali::Dimension::Type)jarg2;
56692   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56693   {
56694     try {
56695       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
56696     } catch (std::out_of_range& e) {
56697       {
56698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56699       };
56700     } catch (std::exception& e) {
56701       {
56702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56703       };
56704     } catch (...) {
56705       {
56706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56707       };
56708     }
56709   }
56710   jresult = result;
56711   return jresult;
56712 }
56713
56714
56715 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
56716   unsigned int jresult ;
56717   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56718   SwigDirector_ViewImpl *darg = 0;
56719   bool result;
56720
56721   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56722   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56723   {
56724     try {
56725       result = (bool)(darg)->RelayoutDependentOnChildren();
56726     } catch (std::out_of_range& e) {
56727       {
56728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56729       };
56730     } catch (std::exception& e) {
56731       {
56732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56733       };
56734     } catch (...) {
56735       {
56736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56737       };
56738     }
56739   }
56740   jresult = result;
56741   return jresult;
56742 }
56743
56744
56745 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
56746   unsigned int jresult ;
56747   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56748   SwigDirector_ViewImpl *darg = 0;
56749   bool result;
56750
56751   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56752   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56753   {
56754     try {
56755       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
56756     } catch (std::out_of_range& e) {
56757       {
56758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56759       };
56760     } catch (std::exception& e) {
56761       {
56762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56763       };
56764     } catch (...) {
56765       {
56766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56767       };
56768     }
56769   }
56770   jresult = result;
56771   return jresult;
56772 }
56773
56774
56775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
56776   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56777   Dali::Dimension::Type arg2 ;
56778   SwigDirector_ViewImpl *darg = 0;
56779
56780   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56781   arg2 = (Dali::Dimension::Type)jarg2;
56782   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56783   {
56784     try {
56785       (darg)->OnCalculateRelayoutSize(arg2);
56786     } catch (std::out_of_range& e) {
56787       {
56788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56789       };
56790     } catch (std::exception& e) {
56791       {
56792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56793       };
56794     } catch (...) {
56795       {
56796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56797       };
56798     }
56799   }
56800 }
56801
56802
56803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
56804   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56805   Dali::Dimension::Type arg2 ;
56806   SwigDirector_ViewImpl *darg = 0;
56807
56808   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56809   arg2 = (Dali::Dimension::Type)jarg2;
56810   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56811   {
56812     try {
56813       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
56814     } catch (std::out_of_range& e) {
56815       {
56816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56817       };
56818     } catch (std::exception& e) {
56819       {
56820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56821       };
56822     } catch (...) {
56823       {
56824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56825       };
56826     }
56827   }
56828 }
56829
56830
56831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
56832   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56833   float arg2 ;
56834   Dali::Dimension::Type arg3 ;
56835   SwigDirector_ViewImpl *darg = 0;
56836
56837   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56838   arg2 = (float)jarg2;
56839   arg3 = (Dali::Dimension::Type)jarg3;
56840   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56841   {
56842     try {
56843       (darg)->OnLayoutNegotiated(arg2,arg3);
56844     } catch (std::out_of_range& e) {
56845       {
56846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56847       };
56848     } catch (std::exception& e) {
56849       {
56850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56851       };
56852     } catch (...) {
56853       {
56854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56855       };
56856     }
56857   }
56858 }
56859
56860
56861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
56862   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56863   float arg2 ;
56864   Dali::Dimension::Type arg3 ;
56865   SwigDirector_ViewImpl *darg = 0;
56866
56867   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56868   arg2 = (float)jarg2;
56869   arg3 = (Dali::Dimension::Type)jarg3;
56870   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56871   {
56872     try {
56873       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
56874     } catch (std::out_of_range& e) {
56875       {
56876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56877       };
56878     } catch (std::exception& e) {
56879       {
56880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56881       };
56882     } catch (...) {
56883       {
56884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56885       };
56886     }
56887   }
56888 }
56889
56890
56891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
56892   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56893
56894   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56895   {
56896     try {
56897       (arg1)->OnInitialize();
56898     } catch (std::out_of_range& e) {
56899       {
56900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56901       };
56902     } catch (std::exception& e) {
56903       {
56904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56905       };
56906     } catch (...) {
56907       {
56908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56909       };
56910     }
56911   }
56912 }
56913
56914
56915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
56916   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56917
56918   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56919   {
56920     try {
56921       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
56922     } catch (std::out_of_range& e) {
56923       {
56924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56925       };
56926     } catch (std::exception& e) {
56927       {
56928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56929       };
56930     } catch (...) {
56931       {
56932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56933       };
56934     }
56935   }
56936 }
56937
56938
56939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
56940   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56941   Dali::Actor *arg2 = 0 ;
56942
56943   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56944   arg2 = (Dali::Actor *)jarg2;
56945   if (!arg2) {
56946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
56947     return ;
56948   }
56949   {
56950     try {
56951       (arg1)->OnControlChildAdd(*arg2);
56952     } catch (std::out_of_range& e) {
56953       {
56954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56955       };
56956     } catch (std::exception& e) {
56957       {
56958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56959       };
56960     } catch (...) {
56961       {
56962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56963       };
56964     }
56965   }
56966 }
56967
56968
56969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
56970   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56971   Dali::Actor *arg2 = 0 ;
56972
56973   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56974   arg2 = (Dali::Actor *)jarg2;
56975   if (!arg2) {
56976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
56977     return ;
56978   }
56979   {
56980     try {
56981       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
56982     } catch (std::out_of_range& e) {
56983       {
56984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56985       };
56986     } catch (std::exception& e) {
56987       {
56988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56989       };
56990     } catch (...) {
56991       {
56992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56993       };
56994     }
56995   }
56996 }
56997
56998
56999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
57000   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57001   Dali::Actor *arg2 = 0 ;
57002
57003   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57004   arg2 = (Dali::Actor *)jarg2;
57005   if (!arg2) {
57006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
57007     return ;
57008   }
57009   {
57010     try {
57011       (arg1)->OnControlChildRemove(*arg2);
57012     } catch (std::out_of_range& e) {
57013       {
57014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57015       };
57016     } catch (std::exception& e) {
57017       {
57018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57019       };
57020     } catch (...) {
57021       {
57022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57023       };
57024     }
57025   }
57026 }
57027
57028
57029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57030   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57031   Dali::Actor *arg2 = 0 ;
57032
57033   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57034   arg2 = (Dali::Actor *)jarg2;
57035   if (!arg2) {
57036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
57037     return ;
57038   }
57039   {
57040     try {
57041       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
57042     } catch (std::out_of_range& e) {
57043       {
57044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57045       };
57046     } catch (std::exception& e) {
57047       {
57048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57049       };
57050     } catch (...) {
57051       {
57052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57053       };
57054     }
57055   }
57056 }
57057
57058
57059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
57060   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57061   Dali::Toolkit::StyleManager arg2 ;
57062   Dali::StyleChange::Type arg3 ;
57063   Dali::Toolkit::StyleManager *argp2 ;
57064
57065   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57066   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
57067   if (!argp2) {
57068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
57069     return ;
57070   }
57071   arg2 = *argp2;
57072   arg3 = (Dali::StyleChange::Type)jarg3;
57073   {
57074     try {
57075       (arg1)->OnStyleChange(arg2,arg3);
57076     } catch (std::out_of_range& e) {
57077       {
57078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57079       };
57080     } catch (std::exception& e) {
57081       {
57082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57083       };
57084     } catch (...) {
57085       {
57086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57087       };
57088     }
57089   }
57090 }
57091
57092
57093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
57094   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57095   Dali::Toolkit::StyleManager arg2 ;
57096   Dali::StyleChange::Type arg3 ;
57097   Dali::Toolkit::StyleManager *argp2 ;
57098
57099   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57100   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
57101   if (!argp2) {
57102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
57103     return ;
57104   }
57105   arg2 = *argp2;
57106   arg3 = (Dali::StyleChange::Type)jarg3;
57107   {
57108     try {
57109       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
57110     } catch (std::out_of_range& e) {
57111       {
57112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57113       };
57114     } catch (std::exception& e) {
57115       {
57116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57117       };
57118     } catch (...) {
57119       {
57120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57121       };
57122     }
57123   }
57124 }
57125
57126
57127 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
57128   unsigned int jresult ;
57129   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57130   bool result;
57131
57132   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57133   {
57134     try {
57135       result = (bool)(arg1)->OnAccessibilityActivated();
57136     } catch (std::out_of_range& e) {
57137       {
57138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57139       };
57140     } catch (std::exception& e) {
57141       {
57142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57143       };
57144     } catch (...) {
57145       {
57146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57147       };
57148     }
57149   }
57150   jresult = result;
57151   return jresult;
57152 }
57153
57154
57155 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
57156   unsigned int jresult ;
57157   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57158   bool result;
57159
57160   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57161   {
57162     try {
57163       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
57164     } catch (std::out_of_range& e) {
57165       {
57166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57167       };
57168     } catch (std::exception& e) {
57169       {
57170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57171       };
57172     } catch (...) {
57173       {
57174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57175       };
57176     }
57177   }
57178   jresult = result;
57179   return jresult;
57180 }
57181
57182
57183 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
57184   unsigned int jresult ;
57185   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57186   Dali::PanGesture arg2 ;
57187   Dali::PanGesture *argp2 ;
57188   bool result;
57189
57190   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57191   argp2 = (Dali::PanGesture *)jarg2;
57192   if (!argp2) {
57193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
57194     return 0;
57195   }
57196   arg2 = *argp2;
57197   {
57198     try {
57199       result = (bool)(arg1)->OnAccessibilityPan(arg2);
57200     } catch (std::out_of_range& e) {
57201       {
57202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57203       };
57204     } catch (std::exception& e) {
57205       {
57206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57207       };
57208     } catch (...) {
57209       {
57210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57211       };
57212     }
57213   }
57214   jresult = result;
57215   return jresult;
57216 }
57217
57218
57219 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57220   unsigned int jresult ;
57221   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57222   Dali::PanGesture arg2 ;
57223   Dali::PanGesture *argp2 ;
57224   bool result;
57225
57226   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57227   argp2 = (Dali::PanGesture *)jarg2;
57228   if (!argp2) {
57229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
57230     return 0;
57231   }
57232   arg2 = *argp2;
57233   {
57234     try {
57235       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
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 = result;
57251   return jresult;
57252 }
57253
57254
57255 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
57256   unsigned int jresult ;
57257   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57258   Dali::TouchEvent *arg2 = 0 ;
57259   bool result;
57260
57261   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57262   arg2 = (Dali::TouchEvent *)jarg2;
57263   if (!arg2) {
57264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
57265     return 0;
57266   }
57267   {
57268     try {
57269       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
57270     } catch (std::out_of_range& e) {
57271       {
57272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57273       };
57274     } catch (std::exception& e) {
57275       {
57276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57277       };
57278     } catch (...) {
57279       {
57280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57281       };
57282     }
57283   }
57284   jresult = result;
57285   return jresult;
57286 }
57287
57288
57289 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57290   unsigned int jresult ;
57291   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57292   Dali::TouchEvent *arg2 = 0 ;
57293   bool result;
57294
57295   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57296   arg2 = (Dali::TouchEvent *)jarg2;
57297   if (!arg2) {
57298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
57299     return 0;
57300   }
57301   {
57302     try {
57303       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
57304     } catch (std::out_of_range& e) {
57305       {
57306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57307       };
57308     } catch (std::exception& e) {
57309       {
57310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57311       };
57312     } catch (...) {
57313       {
57314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57315       };
57316     }
57317   }
57318   jresult = result;
57319   return jresult;
57320 }
57321
57322
57323 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
57324   unsigned int jresult ;
57325   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57326   bool arg2 ;
57327   bool result;
57328
57329   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57330   arg2 = jarg2 ? true : false;
57331   {
57332     try {
57333       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
57334     } catch (std::out_of_range& e) {
57335       {
57336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57337       };
57338     } catch (std::exception& e) {
57339       {
57340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57341       };
57342     } catch (...) {
57343       {
57344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57345       };
57346     }
57347   }
57348   jresult = result;
57349   return jresult;
57350 }
57351
57352
57353 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
57354   unsigned int jresult ;
57355   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57356   bool arg2 ;
57357   bool result;
57358
57359   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57360   arg2 = jarg2 ? true : false;
57361   {
57362     try {
57363       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
57364     } catch (std::out_of_range& e) {
57365       {
57366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57367       };
57368     } catch (std::exception& e) {
57369       {
57370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57371       };
57372     } catch (...) {
57373       {
57374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57375       };
57376     }
57377   }
57378   jresult = result;
57379   return jresult;
57380 }
57381
57382
57383 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
57384   unsigned int jresult ;
57385   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57386   bool result;
57387
57388   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57389   {
57390     try {
57391       result = (bool)(arg1)->OnAccessibilityZoom();
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 = result;
57407   return jresult;
57408 }
57409
57410
57411 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
57412   unsigned int jresult ;
57413   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57414   bool result;
57415
57416   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57417   {
57418     try {
57419       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
57420     } catch (std::out_of_range& e) {
57421       {
57422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57423       };
57424     } catch (std::exception& e) {
57425       {
57426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57427       };
57428     } catch (...) {
57429       {
57430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57431       };
57432     }
57433   }
57434   jresult = result;
57435   return jresult;
57436 }
57437
57438
57439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
57440   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57441
57442   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57443   {
57444     try {
57445       (arg1)->OnKeyInputFocusGained();
57446     } catch (std::out_of_range& e) {
57447       {
57448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57449       };
57450     } catch (std::exception& e) {
57451       {
57452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57453       };
57454     } catch (...) {
57455       {
57456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57457       };
57458     }
57459   }
57460 }
57461
57462
57463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
57464   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57465
57466   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57467   {
57468     try {
57469       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
57470     } catch (std::out_of_range& e) {
57471       {
57472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57473       };
57474     } catch (std::exception& e) {
57475       {
57476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57477       };
57478     } catch (...) {
57479       {
57480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57481       };
57482     }
57483   }
57484 }
57485
57486
57487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
57488   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57489
57490   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57491   {
57492     try {
57493       (arg1)->OnKeyInputFocusLost();
57494     } catch (std::out_of_range& e) {
57495       {
57496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57497       };
57498     } catch (std::exception& e) {
57499       {
57500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57501       };
57502     } catch (...) {
57503       {
57504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57505       };
57506     }
57507   }
57508 }
57509
57510
57511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
57512   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57513
57514   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57515   {
57516     try {
57517       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
57518     } catch (std::out_of_range& e) {
57519       {
57520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57521       };
57522     } catch (std::exception& e) {
57523       {
57524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57525       };
57526     } catch (...) {
57527       {
57528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57529       };
57530     }
57531   }
57532 }
57533
57534
57535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
57536   void * jresult ;
57537   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57538   Dali::Actor arg2 ;
57539   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
57540   bool arg4 ;
57541   Dali::Actor *argp2 ;
57542   Dali::Actor result;
57543
57544   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57545   argp2 = (Dali::Actor *)jarg2;
57546   if (!argp2) {
57547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57548     return 0;
57549   }
57550   arg2 = *argp2;
57551   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
57552   arg4 = jarg4 ? true : false;
57553   {
57554     try {
57555       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
57556     } catch (std::out_of_range& e) {
57557       {
57558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57559       };
57560     } catch (std::exception& e) {
57561       {
57562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57563       };
57564     } catch (...) {
57565       {
57566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57567       };
57568     }
57569   }
57570   jresult = new Dali::Actor((const Dali::Actor &)result);
57571   return jresult;
57572 }
57573
57574
57575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
57576   void * jresult ;
57577   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57578   Dali::Actor arg2 ;
57579   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
57580   bool arg4 ;
57581   Dali::Actor *argp2 ;
57582   Dali::Actor result;
57583
57584   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57585   argp2 = (Dali::Actor *)jarg2;
57586   if (!argp2) {
57587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57588     return 0;
57589   }
57590   arg2 = *argp2;
57591   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
57592   arg4 = jarg4 ? true : false;
57593   {
57594     try {
57595       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
57596     } catch (std::out_of_range& e) {
57597       {
57598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57599       };
57600     } catch (std::exception& e) {
57601       {
57602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57603       };
57604     } catch (...) {
57605       {
57606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57607       };
57608     }
57609   }
57610   jresult = new Dali::Actor((const Dali::Actor &)result);
57611   return jresult;
57612 }
57613
57614
57615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
57616   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57617   Dali::Actor arg2 ;
57618   Dali::Actor *argp2 ;
57619
57620   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57621   argp2 = (Dali::Actor *)jarg2;
57622   if (!argp2) {
57623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57624     return ;
57625   }
57626   arg2 = *argp2;
57627   {
57628     try {
57629       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
57630     } catch (std::out_of_range& e) {
57631       {
57632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57633       };
57634     } catch (std::exception& e) {
57635       {
57636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57637       };
57638     } catch (...) {
57639       {
57640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57641       };
57642     }
57643   }
57644 }
57645
57646
57647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57648   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57649   Dali::Actor arg2 ;
57650   Dali::Actor *argp2 ;
57651
57652   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57653   argp2 = (Dali::Actor *)jarg2;
57654   if (!argp2) {
57655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57656     return ;
57657   }
57658   arg2 = *argp2;
57659   {
57660     try {
57661       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
57662     } catch (std::out_of_range& e) {
57663       {
57664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57665       };
57666     } catch (std::exception& e) {
57667       {
57668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57669       };
57670     } catch (...) {
57671       {
57672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57673       };
57674     }
57675   }
57676 }
57677
57678
57679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
57680   unsigned int jresult ;
57681   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57682   bool result;
57683
57684   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57685   {
57686     try {
57687       result = (bool)(arg1)->OnKeyboardEnter();
57688     } catch (std::out_of_range& e) {
57689       {
57690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57691       };
57692     } catch (std::exception& e) {
57693       {
57694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57695       };
57696     } catch (...) {
57697       {
57698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57699       };
57700     }
57701   }
57702   jresult = result;
57703   return jresult;
57704 }
57705
57706
57707 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
57708   unsigned int jresult ;
57709   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57710   bool result;
57711
57712   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57713   {
57714     try {
57715       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
57716     } catch (std::out_of_range& e) {
57717       {
57718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57719       };
57720     } catch (std::exception& e) {
57721       {
57722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57723       };
57724     } catch (...) {
57725       {
57726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57727       };
57728     }
57729   }
57730   jresult = result;
57731   return jresult;
57732 }
57733
57734
57735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
57736   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57737   Dali::PinchGesture *arg2 = 0 ;
57738
57739   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57740   arg2 = (Dali::PinchGesture *)jarg2;
57741   if (!arg2) {
57742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57743     return ;
57744   }
57745   {
57746     try {
57747       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
57748     } catch (std::out_of_range& e) {
57749       {
57750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57751       };
57752     } catch (std::exception& e) {
57753       {
57754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57755       };
57756     } catch (...) {
57757       {
57758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57759       };
57760     }
57761   }
57762 }
57763
57764
57765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57766   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57767   Dali::PinchGesture *arg2 = 0 ;
57768
57769   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57770   arg2 = (Dali::PinchGesture *)jarg2;
57771   if (!arg2) {
57772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57773     return ;
57774   }
57775   {
57776     try {
57777       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
57778     } catch (std::out_of_range& e) {
57779       {
57780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57781       };
57782     } catch (std::exception& e) {
57783       {
57784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57785       };
57786     } catch (...) {
57787       {
57788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57789       };
57790     }
57791   }
57792 }
57793
57794
57795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
57796   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57797   Dali::PanGesture *arg2 = 0 ;
57798
57799   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57800   arg2 = (Dali::PanGesture *)jarg2;
57801   if (!arg2) {
57802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57803     return ;
57804   }
57805   {
57806     try {
57807       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
57808     } catch (std::out_of_range& e) {
57809       {
57810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57811       };
57812     } catch (std::exception& e) {
57813       {
57814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57815       };
57816     } catch (...) {
57817       {
57818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57819       };
57820     }
57821   }
57822 }
57823
57824
57825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57826   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57827   Dali::PanGesture *arg2 = 0 ;
57828
57829   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57830   arg2 = (Dali::PanGesture *)jarg2;
57831   if (!arg2) {
57832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57833     return ;
57834   }
57835   {
57836     try {
57837       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
57838     } catch (std::out_of_range& e) {
57839       {
57840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57841       };
57842     } catch (std::exception& e) {
57843       {
57844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57845       };
57846     } catch (...) {
57847       {
57848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57849       };
57850     }
57851   }
57852 }
57853
57854
57855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
57856   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57857   Dali::TapGesture *arg2 = 0 ;
57858
57859   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57860   arg2 = (Dali::TapGesture *)jarg2;
57861   if (!arg2) {
57862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57863     return ;
57864   }
57865   {
57866     try {
57867       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
57868     } catch (std::out_of_range& e) {
57869       {
57870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57871       };
57872     } catch (std::exception& e) {
57873       {
57874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57875       };
57876     } catch (...) {
57877       {
57878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57879       };
57880     }
57881   }
57882 }
57883
57884
57885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57886   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57887   Dali::TapGesture *arg2 = 0 ;
57888
57889   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57890   arg2 = (Dali::TapGesture *)jarg2;
57891   if (!arg2) {
57892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57893     return ;
57894   }
57895   {
57896     try {
57897       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
57898     } catch (std::out_of_range& e) {
57899       {
57900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57901       };
57902     } catch (std::exception& e) {
57903       {
57904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57905       };
57906     } catch (...) {
57907       {
57908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57909       };
57910     }
57911   }
57912 }
57913
57914
57915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
57916   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57917   Dali::LongPressGesture *arg2 = 0 ;
57918
57919   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57920   arg2 = (Dali::LongPressGesture *)jarg2;
57921   if (!arg2) {
57922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
57923     return ;
57924   }
57925   {
57926     try {
57927       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
57928     } catch (std::out_of_range& e) {
57929       {
57930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57931       };
57932     } catch (std::exception& e) {
57933       {
57934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57935       };
57936     } catch (...) {
57937       {
57938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57939       };
57940     }
57941   }
57942 }
57943
57944
57945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57946   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57947   Dali::LongPressGesture *arg2 = 0 ;
57948
57949   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57950   arg2 = (Dali::LongPressGesture *)jarg2;
57951   if (!arg2) {
57952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
57953     return ;
57954   }
57955   {
57956     try {
57957       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
57958     } catch (std::out_of_range& e) {
57959       {
57960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57961       };
57962     } catch (std::exception& e) {
57963       {
57964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57965       };
57966     } catch (...) {
57967       {
57968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57969       };
57970     }
57971   }
57972 }
57973
57974
57975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
57976   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57977   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
57978   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
57979
57980   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57981   arg2 = (Dali::SlotObserver *)jarg2;
57982   arg3 = (Dali::CallbackBase *)jarg3;
57983   {
57984     try {
57985       (arg1)->SignalConnected(arg2,arg3);
57986     } catch (std::out_of_range& e) {
57987       {
57988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57989       };
57990     } catch (std::exception& e) {
57991       {
57992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57993       };
57994     } catch (...) {
57995       {
57996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57997       };
57998     }
57999   }
58000 }
58001
58002
58003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
58004   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58005   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
58006   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
58007
58008   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58009   arg2 = (Dali::SlotObserver *)jarg2;
58010   arg3 = (Dali::CallbackBase *)jarg3;
58011   {
58012     try {
58013       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
58014     } catch (std::out_of_range& e) {
58015       {
58016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58017       };
58018     } catch (std::exception& e) {
58019       {
58020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58021       };
58022     } catch (...) {
58023       {
58024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58025       };
58026     }
58027   }
58028 }
58029
58030
58031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
58032   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58033   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
58034   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
58035
58036   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58037   arg2 = (Dali::SlotObserver *)jarg2;
58038   arg3 = (Dali::CallbackBase *)jarg3;
58039   {
58040     try {
58041       (arg1)->SignalDisconnected(arg2,arg3);
58042     } catch (std::out_of_range& e) {
58043       {
58044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58045       };
58046     } catch (std::exception& e) {
58047       {
58048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58049       };
58050     } catch (...) {
58051       {
58052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58053       };
58054     }
58055   }
58056 }
58057
58058
58059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
58060   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58061   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
58062   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
58063
58064   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58065   arg2 = (Dali::SlotObserver *)jarg2;
58066   arg3 = (Dali::CallbackBase *)jarg3;
58067   {
58068     try {
58069       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
58070     } catch (std::out_of_range& e) {
58071       {
58072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58073       };
58074     } catch (std::exception& e) {
58075       {
58076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58077       };
58078     } catch (...) {
58079       {
58080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58081       };
58082     }
58083   }
58084 }
58085
58086
58087 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) {
58088   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
58089   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
58090   if (director) {
58091     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);
58092   }
58093 }
58094
58095
58096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
58097   void * jresult ;
58098   Dali::Toolkit::Control *arg1 = 0 ;
58099   Dali::Toolkit::Internal::Control *result = 0 ;
58100
58101   arg1 = (Dali::Toolkit::Control *)jarg1;
58102   if (!arg1) {
58103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
58104     return 0;
58105   }
58106   {
58107     try {
58108       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
58109     } catch (std::out_of_range& e) {
58110       {
58111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58112       };
58113     } catch (std::exception& e) {
58114       {
58115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58116       };
58117     } catch (...) {
58118       {
58119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58120       };
58121     }
58122   }
58123   jresult = (void *)result;
58124   return jresult;
58125 }
58126
58127
58128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
58129   int jresult ;
58130   int result;
58131
58132   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
58133   jresult = (int)result;
58134   return jresult;
58135 }
58136
58137
58138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
58139   int jresult ;
58140   int result;
58141
58142   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
58143   jresult = (int)result;
58144   return jresult;
58145 }
58146
58147
58148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
58149   int jresult ;
58150   int result;
58151
58152   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
58153   jresult = (int)result;
58154   return jresult;
58155 }
58156
58157
58158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
58159   int jresult ;
58160   int result;
58161
58162   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
58163   jresult = (int)result;
58164   return jresult;
58165 }
58166
58167
58168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
58169   int jresult ;
58170   int result;
58171
58172   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
58173   jresult = (int)result;
58174   return jresult;
58175 }
58176
58177
58178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
58179   void * jresult ;
58180   Dali::Toolkit::Control::Property *result = 0 ;
58181
58182   {
58183     try {
58184       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
58185     } catch (std::out_of_range& e) {
58186       {
58187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58188       };
58189     } catch (std::exception& e) {
58190       {
58191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58192       };
58193     } catch (...) {
58194       {
58195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58196       };
58197     }
58198   }
58199   jresult = (void *)result;
58200   return jresult;
58201 }
58202
58203
58204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
58205   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
58206
58207   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
58208   {
58209     try {
58210       delete arg1;
58211     } catch (std::out_of_range& e) {
58212       {
58213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58214       };
58215     } catch (std::exception& e) {
58216       {
58217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58218       };
58219     } catch (...) {
58220       {
58221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58222       };
58223     }
58224   }
58225 }
58226
58227
58228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
58229   void * jresult ;
58230   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
58231
58232   {
58233     try {
58234       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
58235     } catch (std::out_of_range& e) {
58236       {
58237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58238       };
58239     } catch (std::exception& e) {
58240       {
58241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58242       };
58243     } catch (...) {
58244       {
58245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58246       };
58247     }
58248   }
58249   jresult = (void *)result;
58250   return jresult;
58251 }
58252
58253
58254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
58255   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
58256
58257   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
58258   {
58259     try {
58260       delete arg1;
58261     } catch (std::out_of_range& e) {
58262       {
58263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58264       };
58265     } catch (std::exception& e) {
58266       {
58267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58268       };
58269     } catch (...) {
58270       {
58271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58272       };
58273     }
58274   }
58275 }
58276
58277
58278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
58279   void * jresult ;
58280   Dali::Toolkit::Control result;
58281
58282   {
58283     try {
58284       result = Dali::Toolkit::Control::New();
58285     } catch (std::out_of_range& e) {
58286       {
58287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58288       };
58289     } catch (std::exception& e) {
58290       {
58291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58292       };
58293     } catch (...) {
58294       {
58295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58296       };
58297     }
58298   }
58299   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
58300   return jresult;
58301 }
58302
58303
58304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
58305   void * jresult ;
58306   Dali::Toolkit::Control *result = 0 ;
58307
58308   {
58309     try {
58310       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
58311     } catch (std::out_of_range& e) {
58312       {
58313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58314       };
58315     } catch (std::exception& e) {
58316       {
58317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58318       };
58319     } catch (...) {
58320       {
58321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58322       };
58323     }
58324   }
58325   jresult = (void *)result;
58326   return jresult;
58327 }
58328
58329
58330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
58331   void * jresult ;
58332   Dali::Toolkit::Control *arg1 = 0 ;
58333   Dali::Toolkit::Control *result = 0 ;
58334
58335   arg1 = (Dali::Toolkit::Control *)jarg1;
58336   if (!arg1) {
58337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
58338     return 0;
58339   }
58340   {
58341     try {
58342       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
58343     } catch (std::out_of_range& e) {
58344       {
58345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58346       };
58347     } catch (std::exception& e) {
58348       {
58349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58350       };
58351     } catch (...) {
58352       {
58353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58354       };
58355     }
58356   }
58357   jresult = (void *)result;
58358   return jresult;
58359 }
58360
58361
58362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
58363   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58364
58365   arg1 = (Dali::Toolkit::Control *)jarg1;
58366   {
58367     try {
58368       delete arg1;
58369     } catch (std::out_of_range& e) {
58370       {
58371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58372       };
58373     } catch (std::exception& e) {
58374       {
58375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58376       };
58377     } catch (...) {
58378       {
58379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58380       };
58381     }
58382   }
58383 }
58384
58385
58386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
58387   void * jresult ;
58388   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58389   Dali::Toolkit::Control *arg2 = 0 ;
58390   Dali::Toolkit::Control *result = 0 ;
58391
58392   arg1 = (Dali::Toolkit::Control *)jarg1;
58393   arg2 = (Dali::Toolkit::Control *)jarg2;
58394   if (!arg2) {
58395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
58396     return 0;
58397   }
58398   {
58399     try {
58400       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
58401     } catch (std::out_of_range& e) {
58402       {
58403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58404       };
58405     } catch (std::exception& e) {
58406       {
58407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58408       };
58409     } catch (...) {
58410       {
58411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58412       };
58413     }
58414   }
58415   jresult = (void *)result;
58416   return jresult;
58417 }
58418
58419
58420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
58421   void * jresult ;
58422   Dali::BaseHandle arg1 ;
58423   Dali::BaseHandle *argp1 ;
58424   Dali::Toolkit::Control result;
58425
58426   argp1 = (Dali::BaseHandle *)jarg1;
58427   if (!argp1) {
58428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58429     return 0;
58430   }
58431   arg1 = *argp1;
58432   {
58433     try {
58434       result = Dali::Toolkit::Control::DownCast(arg1);
58435     } catch (std::out_of_range& e) {
58436       {
58437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58438       };
58439     } catch (std::exception& e) {
58440       {
58441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58442       };
58443     } catch (...) {
58444       {
58445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58446       };
58447     }
58448   }
58449   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
58450   return jresult;
58451 }
58452
58453
58454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
58455   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58456
58457   arg1 = (Dali::Toolkit::Control *)jarg1;
58458   {
58459     try {
58460       (arg1)->SetKeyInputFocus();
58461     } catch (std::out_of_range& e) {
58462       {
58463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58464       };
58465     } catch (std::exception& e) {
58466       {
58467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58468       };
58469     } catch (...) {
58470       {
58471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58472       };
58473     }
58474   }
58475 }
58476
58477
58478 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
58479   unsigned int jresult ;
58480   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58481   bool result;
58482
58483   arg1 = (Dali::Toolkit::Control *)jarg1;
58484   {
58485     try {
58486       result = (bool)(arg1)->HasKeyInputFocus();
58487     } catch (std::out_of_range& e) {
58488       {
58489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58490       };
58491     } catch (std::exception& e) {
58492       {
58493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58494       };
58495     } catch (...) {
58496       {
58497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58498       };
58499     }
58500   }
58501   jresult = result;
58502   return jresult;
58503 }
58504
58505
58506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
58507   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58508
58509   arg1 = (Dali::Toolkit::Control *)jarg1;
58510   {
58511     try {
58512       (arg1)->ClearKeyInputFocus();
58513     } catch (std::out_of_range& e) {
58514       {
58515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58516       };
58517     } catch (std::exception& e) {
58518       {
58519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58520       };
58521     } catch (...) {
58522       {
58523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58524       };
58525     }
58526   }
58527 }
58528
58529
58530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
58531   void * jresult ;
58532   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58533   Dali::PinchGestureDetector result;
58534
58535   arg1 = (Dali::Toolkit::Control *)jarg1;
58536   {
58537     try {
58538       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
58539     } catch (std::out_of_range& e) {
58540       {
58541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58542       };
58543     } catch (std::exception& e) {
58544       {
58545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58546       };
58547     } catch (...) {
58548       {
58549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58550       };
58551     }
58552   }
58553   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
58554   return jresult;
58555 }
58556
58557
58558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
58559   void * jresult ;
58560   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58561   Dali::PanGestureDetector result;
58562
58563   arg1 = (Dali::Toolkit::Control *)jarg1;
58564   {
58565     try {
58566       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
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::PanGestureDetector((const Dali::PanGestureDetector &)result);
58582   return jresult;
58583 }
58584
58585
58586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
58587   void * jresult ;
58588   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58589   Dali::TapGestureDetector result;
58590
58591   arg1 = (Dali::Toolkit::Control *)jarg1;
58592   {
58593     try {
58594       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
58595     } catch (std::out_of_range& e) {
58596       {
58597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58598       };
58599     } catch (std::exception& e) {
58600       {
58601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58602       };
58603     } catch (...) {
58604       {
58605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58606       };
58607     }
58608   }
58609   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
58610   return jresult;
58611 }
58612
58613
58614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
58615   void * jresult ;
58616   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58617   Dali::LongPressGestureDetector result;
58618
58619   arg1 = (Dali::Toolkit::Control *)jarg1;
58620   {
58621     try {
58622       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
58623     } catch (std::out_of_range& e) {
58624       {
58625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58626       };
58627     } catch (std::exception& e) {
58628       {
58629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58630       };
58631     } catch (...) {
58632       {
58633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58634       };
58635     }
58636   }
58637   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
58638   return jresult;
58639 }
58640
58641
58642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
58643   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58644   std::string *arg2 = 0 ;
58645
58646   arg1 = (Dali::Toolkit::Control *)jarg1;
58647   if (!jarg2) {
58648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58649     return ;
58650   }
58651   std::string arg2_str(jarg2);
58652   arg2 = &arg2_str;
58653   {
58654     try {
58655       (arg1)->SetStyleName((std::string const &)*arg2);
58656     } catch (std::out_of_range& e) {
58657       {
58658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58659       };
58660     } catch (std::exception& e) {
58661       {
58662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58663       };
58664     } catch (...) {
58665       {
58666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58667       };
58668     }
58669   }
58670
58671   //argout typemap for const std::string&
58672
58673 }
58674
58675
58676 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
58677   char * jresult ;
58678   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58679   std::string *result = 0 ;
58680
58681   arg1 = (Dali::Toolkit::Control *)jarg1;
58682   {
58683     try {
58684       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
58685     } catch (std::out_of_range& e) {
58686       {
58687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58688       };
58689     } catch (std::exception& e) {
58690       {
58691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58692       };
58693     } catch (...) {
58694       {
58695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58696       };
58697     }
58698   }
58699   jresult = SWIG_csharp_string_callback(result->c_str());
58700   return jresult;
58701 }
58702
58703
58704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
58705   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58706   Dali::Vector4 *arg2 = 0 ;
58707
58708   arg1 = (Dali::Toolkit::Control *)jarg1;
58709   arg2 = (Dali::Vector4 *)jarg2;
58710   if (!arg2) {
58711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
58712     return ;
58713   }
58714   {
58715     try {
58716       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
58717     } catch (std::out_of_range& e) {
58718       {
58719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58720       };
58721     } catch (std::exception& e) {
58722       {
58723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58724       };
58725     } catch (...) {
58726       {
58727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58728       };
58729     }
58730   }
58731 }
58732
58733
58734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
58735   void * jresult ;
58736   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58737   Dali::Vector4 result;
58738
58739   arg1 = (Dali::Toolkit::Control *)jarg1;
58740   {
58741     try {
58742       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
58743     } catch (std::out_of_range& e) {
58744       {
58745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58746       };
58747     } catch (std::exception& e) {
58748       {
58749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58750       };
58751     } catch (...) {
58752       {
58753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58754       };
58755     }
58756   }
58757   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
58758   return jresult;
58759 }
58760
58761
58762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
58763   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58764   Dali::Image arg2 ;
58765   Dali::Image *argp2 ;
58766
58767   arg1 = (Dali::Toolkit::Control *)jarg1;
58768   argp2 = (Dali::Image *)jarg2;
58769   if (!argp2) {
58770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
58771     return ;
58772   }
58773   arg2 = *argp2;
58774   {
58775     try {
58776       (arg1)->SetBackgroundImage(arg2);
58777     } catch (std::out_of_range& e) {
58778       {
58779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58780       };
58781     } catch (std::exception& e) {
58782       {
58783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58784       };
58785     } catch (...) {
58786       {
58787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58788       };
58789     }
58790   }
58791 }
58792
58793
58794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
58795   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58796
58797   arg1 = (Dali::Toolkit::Control *)jarg1;
58798   {
58799     try {
58800       (arg1)->ClearBackground();
58801     } catch (std::out_of_range& e) {
58802       {
58803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58804       };
58805     } catch (std::exception& e) {
58806       {
58807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58808       };
58809     } catch (...) {
58810       {
58811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58812       };
58813     }
58814   }
58815 }
58816
58817
58818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
58819   void * jresult ;
58820   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58821   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
58822
58823   arg1 = (Dali::Toolkit::Control *)jarg1;
58824   {
58825     try {
58826       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
58827     } catch (std::out_of_range& e) {
58828       {
58829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58830       };
58831     } catch (std::exception& e) {
58832       {
58833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58834       };
58835     } catch (...) {
58836       {
58837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58838       };
58839     }
58840   }
58841   jresult = (void *)result;
58842   return jresult;
58843 }
58844
58845
58846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
58847   void * jresult ;
58848   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58849   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
58850
58851   arg1 = (Dali::Toolkit::Control *)jarg1;
58852   {
58853     try {
58854       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
58855     } catch (std::out_of_range& e) {
58856       {
58857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58858       };
58859     } catch (std::exception& e) {
58860       {
58861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58862       };
58863     } catch (...) {
58864       {
58865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58866       };
58867     }
58868   }
58869   jresult = (void *)result;
58870   return jresult;
58871 }
58872
58873
58874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
58875   void * jresult ;
58876   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58877   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
58878
58879   arg1 = (Dali::Toolkit::Control *)jarg1;
58880   {
58881     try {
58882       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
58883     } catch (std::out_of_range& e) {
58884       {
58885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58886       };
58887     } catch (std::exception& e) {
58888       {
58889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58890       };
58891     } catch (...) {
58892       {
58893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58894       };
58895     }
58896   }
58897   jresult = (void *)result;
58898   return jresult;
58899 }
58900
58901
58902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
58903   void * jresult ;
58904   Dali::Toolkit::Internal::Control *arg1 = 0 ;
58905   Dali::Toolkit::Control *result = 0 ;
58906
58907   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58908   if (!arg1) {
58909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
58910     return 0;
58911   }
58912   {
58913     try {
58914       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
58915     } catch (std::out_of_range& e) {
58916       {
58917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58918       };
58919     } catch (std::exception& e) {
58920       {
58921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58922       };
58923     } catch (...) {
58924       {
58925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58926       };
58927     }
58928   }
58929   jresult = (void *)result;
58930   return jresult;
58931 }
58932
58933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
58934 {
58935   void * jresult;
58936   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58937   arg1 = (Dali::Toolkit::Control *)jarg1;
58938
58939   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
58940
58941   Dali::Toolkit::TransitionData *arg2 = 0 ;
58942   Dali::Animation result;
58943
58944   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
58945   if (!arg2) {
58946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58947     return 0;
58948   }
58949   {
58950     try {
58951       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
58952     } catch (std::out_of_range& e) {
58953       {
58954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58955       };
58956     } catch (std::exception& e) {
58957       {
58958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58959       };
58960     } catch (...) {
58961       {
58962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58963       };
58964     }
58965   }
58966   jresult = new Dali::Animation((const Dali::Animation &)result);
58967   return jresult;
58968 }
58969
58970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
58971   void * jresult ;
58972   Dali::Toolkit::Control *arg1 = 0 ;
58973   Dali::Toolkit::DevelControl::ResourceReadySignalType *result = 0 ;
58974
58975   arg1 = (Dali::Toolkit::Control *)jarg1;
58976   if (!arg1) {
58977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
58978     return 0;
58979   }
58980   {
58981     try {
58982       result = (Dali::Toolkit::DevelControl::ResourceReadySignalType *) &Dali::Toolkit::DevelControl::ResourceReadySignal(*arg1);
58983     } catch (std::out_of_range& e) {
58984       {
58985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58986       };
58987     } catch (std::exception& e) {
58988       {
58989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58990       };
58991     } catch (...) {
58992       {
58993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58994       };
58995     }
58996   }
58997   jresult = (void *)result;
58998   return jresult;
58999 }
59000
59001
59002 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
59003   unsigned int jresult ;
59004   Dali::Toolkit::Control *arg1 = 0 ;
59005   bool result;
59006
59007   arg1 = (Dali::Toolkit::Control *)jarg1;
59008   if (!arg1) {
59009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
59010     return 0;
59011   }
59012   {
59013     try {
59014       result = (bool)Dali::Toolkit::DevelControl::IsResourceReady((Dali::Toolkit::Control const &)*arg1);
59015     } catch (std::out_of_range& e) {
59016       {
59017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59018       };
59019     } catch (std::exception& e) {
59020       {
59021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59022       };
59023     } catch (...) {
59024       {
59025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59026       };
59027     }
59028   }
59029   jresult = result;
59030   return jresult;
59031 }
59032
59033
59034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
59035   void * jresult ;
59036   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
59037
59038   {
59039     try {
59040       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
59041     } catch (std::out_of_range& e) {
59042       {
59043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59044       };
59045     } catch (std::exception& e) {
59046       {
59047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59048       };
59049     } catch (...) {
59050       {
59051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59052       };
59053     }
59054   }
59055   jresult = (void *)result;
59056   return jresult;
59057 }
59058
59059
59060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
59061   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
59062
59063   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
59064   {
59065     try {
59066       delete arg1;
59067     } catch (std::out_of_range& e) {
59068       {
59069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59070       };
59071     } catch (std::exception& e) {
59072       {
59073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59074       };
59075     } catch (...) {
59076       {
59077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59078       };
59079     }
59080   }
59081 }
59082
59083
59084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
59085   void * jresult ;
59086   Dali::Toolkit::KeyInputFocusManager result;
59087
59088   {
59089     try {
59090       result = Dali::Toolkit::KeyInputFocusManager::Get();
59091     } catch (std::out_of_range& e) {
59092       {
59093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59094       };
59095     } catch (std::exception& e) {
59096       {
59097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59098       };
59099     } catch (...) {
59100       {
59101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59102       };
59103     }
59104   }
59105   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
59106   return jresult;
59107 }
59108
59109
59110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
59111   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
59112   Dali::Toolkit::Control arg2 ;
59113   Dali::Toolkit::Control *argp2 ;
59114
59115   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
59116   argp2 = (Dali::Toolkit::Control *)jarg2;
59117   if (!argp2) {
59118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
59119     return ;
59120   }
59121   arg2 = *argp2;
59122   {
59123     try {
59124       (arg1)->SetFocus(arg2);
59125     } catch (std::out_of_range& e) {
59126       {
59127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59128       };
59129     } catch (std::exception& e) {
59130       {
59131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59132       };
59133     } catch (...) {
59134       {
59135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59136       };
59137     }
59138   }
59139 }
59140
59141
59142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
59143   void * jresult ;
59144   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
59145   Dali::Toolkit::Control result;
59146
59147   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
59148   {
59149     try {
59150       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
59151     } catch (std::out_of_range& e) {
59152       {
59153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59154       };
59155     } catch (std::exception& e) {
59156       {
59157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59158       };
59159     } catch (...) {
59160       {
59161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59162       };
59163     }
59164   }
59165   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
59166   return jresult;
59167 }
59168
59169
59170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
59171   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
59172   Dali::Toolkit::Control arg2 ;
59173   Dali::Toolkit::Control *argp2 ;
59174
59175   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
59176   argp2 = (Dali::Toolkit::Control *)jarg2;
59177   if (!argp2) {
59178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
59179     return ;
59180   }
59181   arg2 = *argp2;
59182   {
59183     try {
59184       (arg1)->RemoveFocus(arg2);
59185     } catch (std::out_of_range& e) {
59186       {
59187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59188       };
59189     } catch (std::exception& e) {
59190       {
59191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59192       };
59193     } catch (...) {
59194       {
59195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59196       };
59197     }
59198   }
59199 }
59200
59201
59202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
59203   void * jresult ;
59204   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
59205   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
59206
59207   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
59208   {
59209     try {
59210       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
59211     } catch (std::out_of_range& e) {
59212       {
59213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59214       };
59215     } catch (std::exception& e) {
59216       {
59217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59218       };
59219     } catch (...) {
59220       {
59221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59222       };
59223     }
59224   }
59225   jresult = (void *)result;
59226   return jresult;
59227 }
59228
59229
59230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
59231   void * jresult ;
59232   Dali::Toolkit::Alignment::Padding *result = 0 ;
59233
59234   {
59235     try {
59236       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
59237     } catch (std::out_of_range& e) {
59238       {
59239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59240       };
59241     } catch (std::exception& e) {
59242       {
59243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59244       };
59245     } catch (...) {
59246       {
59247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59248       };
59249     }
59250   }
59251   jresult = (void *)result;
59252   return jresult;
59253 }
59254
59255
59256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
59257   void * jresult ;
59258   float arg1 ;
59259   float arg2 ;
59260   float arg3 ;
59261   float arg4 ;
59262   Dali::Toolkit::Alignment::Padding *result = 0 ;
59263
59264   arg1 = (float)jarg1;
59265   arg2 = (float)jarg2;
59266   arg3 = (float)jarg3;
59267   arg4 = (float)jarg4;
59268   {
59269     try {
59270       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
59271     } catch (std::out_of_range& e) {
59272       {
59273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59274       };
59275     } catch (std::exception& e) {
59276       {
59277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59278       };
59279     } catch (...) {
59280       {
59281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59282       };
59283     }
59284   }
59285   jresult = (void *)result;
59286   return jresult;
59287 }
59288
59289
59290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
59291   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59292   float arg2 ;
59293
59294   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59295   arg2 = (float)jarg2;
59296   if (arg1) (arg1)->left = arg2;
59297 }
59298
59299
59300 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
59301   float jresult ;
59302   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59303   float result;
59304
59305   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59306   result = (float) ((arg1)->left);
59307   jresult = result;
59308   return jresult;
59309 }
59310
59311
59312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
59313   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59314   float arg2 ;
59315
59316   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59317   arg2 = (float)jarg2;
59318   if (arg1) (arg1)->right = arg2;
59319 }
59320
59321
59322 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
59323   float jresult ;
59324   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59325   float result;
59326
59327   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59328   result = (float) ((arg1)->right);
59329   jresult = result;
59330   return jresult;
59331 }
59332
59333
59334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
59335   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59336   float arg2 ;
59337
59338   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59339   arg2 = (float)jarg2;
59340   if (arg1) (arg1)->top = arg2;
59341 }
59342
59343
59344 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
59345   float jresult ;
59346   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59347   float result;
59348
59349   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59350   result = (float) ((arg1)->top);
59351   jresult = result;
59352   return jresult;
59353 }
59354
59355
59356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
59357   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59358   float arg2 ;
59359
59360   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59361   arg2 = (float)jarg2;
59362   if (arg1) (arg1)->bottom = arg2;
59363 }
59364
59365
59366 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
59367   float jresult ;
59368   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59369   float result;
59370
59371   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59372   result = (float) ((arg1)->bottom);
59373   jresult = result;
59374   return jresult;
59375 }
59376
59377
59378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
59379   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59380
59381   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59382   {
59383     try {
59384       delete arg1;
59385     } catch (std::out_of_range& e) {
59386       {
59387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59388       };
59389     } catch (std::exception& e) {
59390       {
59391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59392       };
59393     } catch (...) {
59394       {
59395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59396       };
59397     }
59398   }
59399 }
59400
59401
59402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
59403   void * jresult ;
59404   Dali::Toolkit::Alignment *result = 0 ;
59405
59406   {
59407     try {
59408       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
59409     } catch (std::out_of_range& e) {
59410       {
59411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59412       };
59413     } catch (std::exception& e) {
59414       {
59415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59416       };
59417     } catch (...) {
59418       {
59419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59420       };
59421     }
59422   }
59423   jresult = (void *)result;
59424   return jresult;
59425 }
59426
59427
59428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
59429   void * jresult ;
59430   Dali::Toolkit::Alignment::Type arg1 ;
59431   Dali::Toolkit::Alignment::Type arg2 ;
59432   Dali::Toolkit::Alignment result;
59433
59434   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
59435   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
59436   {
59437     try {
59438       result = Dali::Toolkit::Alignment::New(arg1,arg2);
59439     } catch (std::out_of_range& e) {
59440       {
59441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59442       };
59443     } catch (std::exception& e) {
59444       {
59445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59446       };
59447     } catch (...) {
59448       {
59449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59450       };
59451     }
59452   }
59453   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
59454   return jresult;
59455 }
59456
59457
59458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
59459   void * jresult ;
59460   Dali::Toolkit::Alignment::Type arg1 ;
59461   Dali::Toolkit::Alignment result;
59462
59463   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
59464   {
59465     try {
59466       result = Dali::Toolkit::Alignment::New(arg1);
59467     } catch (std::out_of_range& e) {
59468       {
59469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59470       };
59471     } catch (std::exception& e) {
59472       {
59473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59474       };
59475     } catch (...) {
59476       {
59477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59478       };
59479     }
59480   }
59481   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
59482   return jresult;
59483 }
59484
59485
59486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
59487   void * jresult ;
59488   Dali::Toolkit::Alignment result;
59489
59490   {
59491     try {
59492       result = Dali::Toolkit::Alignment::New();
59493     } catch (std::out_of_range& e) {
59494       {
59495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59496       };
59497     } catch (std::exception& e) {
59498       {
59499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59500       };
59501     } catch (...) {
59502       {
59503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59504       };
59505     }
59506   }
59507   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
59508   return jresult;
59509 }
59510
59511
59512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
59513   void * jresult ;
59514   Dali::Toolkit::Alignment *arg1 = 0 ;
59515   Dali::Toolkit::Alignment *result = 0 ;
59516
59517   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59518   if (!arg1) {
59519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
59520     return 0;
59521   }
59522   {
59523     try {
59524       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
59525     } catch (std::out_of_range& e) {
59526       {
59527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59528       };
59529     } catch (std::exception& e) {
59530       {
59531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59532       };
59533     } catch (...) {
59534       {
59535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59536       };
59537     }
59538   }
59539   jresult = (void *)result;
59540   return jresult;
59541 }
59542
59543
59544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
59545   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59546
59547   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59548   {
59549     try {
59550       delete arg1;
59551     } catch (std::out_of_range& e) {
59552       {
59553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59554       };
59555     } catch (std::exception& e) {
59556       {
59557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59558       };
59559     } catch (...) {
59560       {
59561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59562       };
59563     }
59564   }
59565 }
59566
59567
59568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
59569   void * jresult ;
59570   Dali::BaseHandle arg1 ;
59571   Dali::BaseHandle *argp1 ;
59572   Dali::Toolkit::Alignment result;
59573
59574   argp1 = (Dali::BaseHandle *)jarg1;
59575   if (!argp1) {
59576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
59577     return 0;
59578   }
59579   arg1 = *argp1;
59580   {
59581     try {
59582       result = Dali::Toolkit::Alignment::DownCast(arg1);
59583     } catch (std::out_of_range& e) {
59584       {
59585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59586       };
59587     } catch (std::exception& e) {
59588       {
59589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59590       };
59591     } catch (...) {
59592       {
59593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59594       };
59595     }
59596   }
59597   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
59598   return jresult;
59599 }
59600
59601
59602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
59603   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59604   Dali::Toolkit::Alignment::Type arg2 ;
59605
59606   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59607   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
59608   {
59609     try {
59610       (arg1)->SetAlignmentType(arg2);
59611     } catch (std::out_of_range& e) {
59612       {
59613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59614       };
59615     } catch (std::exception& e) {
59616       {
59617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59618       };
59619     } catch (...) {
59620       {
59621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59622       };
59623     }
59624   }
59625 }
59626
59627
59628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
59629   int jresult ;
59630   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59631   Dali::Toolkit::Alignment::Type result;
59632
59633   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59634   {
59635     try {
59636       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
59637     } catch (std::out_of_range& e) {
59638       {
59639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59640       };
59641     } catch (std::exception& e) {
59642       {
59643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59644       };
59645     } catch (...) {
59646       {
59647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59648       };
59649     }
59650   }
59651   jresult = (int)result;
59652   return jresult;
59653 }
59654
59655
59656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
59657   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59658   Dali::Toolkit::Alignment::Scaling arg2 ;
59659
59660   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59661   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
59662   {
59663     try {
59664       (arg1)->SetScaling(arg2);
59665     } catch (std::out_of_range& e) {
59666       {
59667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59668       };
59669     } catch (std::exception& e) {
59670       {
59671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59672       };
59673     } catch (...) {
59674       {
59675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59676       };
59677     }
59678   }
59679 }
59680
59681
59682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
59683   int jresult ;
59684   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59685   Dali::Toolkit::Alignment::Scaling result;
59686
59687   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59688   {
59689     try {
59690       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
59691     } catch (std::out_of_range& e) {
59692       {
59693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59694       };
59695     } catch (std::exception& e) {
59696       {
59697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59698       };
59699     } catch (...) {
59700       {
59701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59702       };
59703     }
59704   }
59705   jresult = (int)result;
59706   return jresult;
59707 }
59708
59709
59710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
59711   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59712   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
59713
59714   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59715   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
59716   if (!arg2) {
59717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
59718     return ;
59719   }
59720   {
59721     try {
59722       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
59723     } catch (std::out_of_range& e) {
59724       {
59725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59726       };
59727     } catch (std::exception& e) {
59728       {
59729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59730       };
59731     } catch (...) {
59732       {
59733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59734       };
59735     }
59736   }
59737 }
59738
59739
59740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
59741   void * jresult ;
59742   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59743   Dali::Toolkit::Alignment::Padding *result = 0 ;
59744
59745   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59746   {
59747     try {
59748       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
59749     } catch (std::out_of_range& e) {
59750       {
59751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59752       };
59753     } catch (std::exception& e) {
59754       {
59755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59756       };
59757     } catch (...) {
59758       {
59759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59760       };
59761     }
59762   }
59763   jresult = (void *)result;
59764   return jresult;
59765 }
59766
59767
59768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
59769   void * jresult ;
59770   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59771   Dali::Toolkit::Alignment *arg2 = 0 ;
59772   Dali::Toolkit::Alignment *result = 0 ;
59773
59774   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59775   arg2 = (Dali::Toolkit::Alignment *)jarg2;
59776   if (!arg2) {
59777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
59778     return 0;
59779   }
59780   {
59781     try {
59782       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
59783     } catch (std::out_of_range& e) {
59784       {
59785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59786       };
59787     } catch (std::exception& e) {
59788       {
59789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59790       };
59791     } catch (...) {
59792       {
59793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59794       };
59795     }
59796   }
59797   jresult = (void *)result;
59798   return jresult;
59799 }
59800
59801
59802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
59803   int jresult ;
59804   int result;
59805
59806   result = (int)Dali::Toolkit::Button::Property::DISABLED;
59807   jresult = (int)result;
59808   return jresult;
59809 }
59810
59811
59812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
59813   int jresult ;
59814   int result;
59815
59816   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
59817   jresult = (int)result;
59818   return jresult;
59819 }
59820
59821
59822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
59823   int jresult ;
59824   int result;
59825
59826   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
59827   jresult = (int)result;
59828   return jresult;
59829 }
59830
59831
59832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
59833   int jresult ;
59834   int result;
59835
59836   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
59837   jresult = (int)result;
59838   return jresult;
59839 }
59840
59841
59842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
59843   int jresult ;
59844   int result;
59845
59846   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
59847   jresult = (int)result;
59848   return jresult;
59849 }
59850
59851
59852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
59853   int jresult ;
59854   int result;
59855
59856   result = (int)Dali::Toolkit::Button::Property::SELECTED;
59857   jresult = (int)result;
59858   return jresult;
59859 }
59860
59861
59862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
59863   int jresult ;
59864   int result;
59865
59866   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
59867   jresult = (int)result;
59868   return jresult;
59869 }
59870
59871
59872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
59873   int jresult ;
59874   int result;
59875
59876   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
59877   jresult = (int)result;
59878   return jresult;
59879 }
59880
59881
59882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
59883   int jresult ;
59884   int result;
59885
59886   result = (int)Dali::Toolkit::Button::Property::LABEL;
59887   jresult = (int)result;
59888   return jresult;
59889 }
59890
59891
59892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
59893   int jresult ;
59894   int result;
59895
59896   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
59897   jresult = (int)result;
59898   return jresult;
59899 }
59900
59901
59902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
59903   void * jresult ;
59904   Dali::Toolkit::Button::Property *result = 0 ;
59905
59906   {
59907     try {
59908       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
59909     } catch (std::out_of_range& e) {
59910       {
59911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59912       };
59913     } catch (std::exception& e) {
59914       {
59915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59916       };
59917     } catch (...) {
59918       {
59919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59920       };
59921     }
59922   }
59923   jresult = (void *)result;
59924   return jresult;
59925 }
59926
59927
59928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
59929   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
59930
59931   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
59932   {
59933     try {
59934       delete arg1;
59935     } catch (std::out_of_range& e) {
59936       {
59937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59938       };
59939     } catch (std::exception& e) {
59940       {
59941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59942       };
59943     } catch (...) {
59944       {
59945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59946       };
59947     }
59948   }
59949 }
59950
59951
59952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
59953   void * jresult ;
59954   Dali::Toolkit::Button *result = 0 ;
59955
59956   {
59957     try {
59958       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
59959     } catch (std::out_of_range& e) {
59960       {
59961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59962       };
59963     } catch (std::exception& e) {
59964       {
59965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59966       };
59967     } catch (...) {
59968       {
59969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59970       };
59971     }
59972   }
59973   jresult = (void *)result;
59974   return jresult;
59975 }
59976
59977
59978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
59979   void * jresult ;
59980   Dali::Toolkit::Button *arg1 = 0 ;
59981   Dali::Toolkit::Button *result = 0 ;
59982
59983   arg1 = (Dali::Toolkit::Button *)jarg1;
59984   if (!arg1) {
59985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
59986     return 0;
59987   }
59988   {
59989     try {
59990       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
59991     } catch (std::out_of_range& e) {
59992       {
59993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59994       };
59995     } catch (std::exception& e) {
59996       {
59997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59998       };
59999     } catch (...) {
60000       {
60001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60002       };
60003     }
60004   }
60005   jresult = (void *)result;
60006   return jresult;
60007 }
60008
60009
60010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
60011   void * jresult ;
60012   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60013   Dali::Toolkit::Button *arg2 = 0 ;
60014   Dali::Toolkit::Button *result = 0 ;
60015
60016   arg1 = (Dali::Toolkit::Button *)jarg1;
60017   arg2 = (Dali::Toolkit::Button *)jarg2;
60018   if (!arg2) {
60019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
60020     return 0;
60021   }
60022   {
60023     try {
60024       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
60025     } catch (std::out_of_range& e) {
60026       {
60027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60028       };
60029     } catch (std::exception& e) {
60030       {
60031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60032       };
60033     } catch (...) {
60034       {
60035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60036       };
60037     }
60038   }
60039   jresult = (void *)result;
60040   return jresult;
60041 }
60042
60043
60044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
60045   void * jresult ;
60046   Dali::BaseHandle arg1 ;
60047   Dali::BaseHandle *argp1 ;
60048   Dali::Toolkit::Button result;
60049
60050   argp1 = (Dali::BaseHandle *)jarg1;
60051   if (!argp1) {
60052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
60053     return 0;
60054   }
60055   arg1 = *argp1;
60056   {
60057     try {
60058       result = Dali::Toolkit::Button::DownCast(arg1);
60059     } catch (std::out_of_range& e) {
60060       {
60061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60062       };
60063     } catch (std::exception& e) {
60064       {
60065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60066       };
60067     } catch (...) {
60068       {
60069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60070       };
60071     }
60072   }
60073   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
60074   return jresult;
60075 }
60076
60077
60078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
60079   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60080
60081   arg1 = (Dali::Toolkit::Button *)jarg1;
60082   {
60083     try {
60084       delete arg1;
60085     } catch (std::out_of_range& e) {
60086       {
60087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60088       };
60089     } catch (std::exception& e) {
60090       {
60091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60092       };
60093     } catch (...) {
60094       {
60095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60096       };
60097     }
60098   }
60099 }
60100
60101
60102 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
60103   unsigned int jresult ;
60104   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60105   bool result;
60106
60107   arg1 = (Dali::Toolkit::Button *)jarg1;
60108   {
60109     try {
60110       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
60111     } catch (std::out_of_range& e) {
60112       {
60113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60114       };
60115     } catch (std::exception& e) {
60116       {
60117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60118       };
60119     } catch (...) {
60120       {
60121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60122       };
60123     }
60124   }
60125   jresult = result;
60126   return jresult;
60127 }
60128
60129
60130 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
60131   unsigned int jresult ;
60132   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60133   bool result;
60134
60135   arg1 = (Dali::Toolkit::Button *)jarg1;
60136   {
60137     try {
60138       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
60139     } catch (std::out_of_range& e) {
60140       {
60141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60142       };
60143     } catch (std::exception& e) {
60144       {
60145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60146       };
60147     } catch (...) {
60148       {
60149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60150       };
60151     }
60152   }
60153   jresult = result;
60154   return jresult;
60155 }
60156
60157
60158 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
60159   float jresult ;
60160   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60161   float result;
60162
60163   arg1 = (Dali::Toolkit::Button *)jarg1;
60164   {
60165     try {
60166       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
60167     } catch (std::out_of_range& e) {
60168       {
60169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60170       };
60171     } catch (std::exception& e) {
60172       {
60173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60174       };
60175     } catch (...) {
60176       {
60177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60178       };
60179     }
60180   }
60181   jresult = result;
60182   return jresult;
60183 }
60184
60185
60186 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
60187   float jresult ;
60188   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60189   float result;
60190
60191   arg1 = (Dali::Toolkit::Button *)jarg1;
60192   {
60193     try {
60194       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
60195     } catch (std::out_of_range& e) {
60196       {
60197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60198       };
60199     } catch (std::exception& e) {
60200       {
60201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60202       };
60203     } catch (...) {
60204       {
60205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60206       };
60207     }
60208   }
60209   jresult = result;
60210   return jresult;
60211 }
60212
60213
60214 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
60215   unsigned int jresult ;
60216   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60217   bool result;
60218
60219   arg1 = (Dali::Toolkit::Button *)jarg1;
60220   {
60221     try {
60222       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
60223     } catch (std::out_of_range& e) {
60224       {
60225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60226       };
60227     } catch (std::exception& e) {
60228       {
60229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60230       };
60231     } catch (...) {
60232       {
60233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60234       };
60235     }
60236   }
60237   jresult = result;
60238   return jresult;
60239 }
60240
60241
60242 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
60243   unsigned int jresult ;
60244   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60245   bool result;
60246
60247   arg1 = (Dali::Toolkit::Button *)jarg1;
60248   {
60249     try {
60250       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
60251     } catch (std::out_of_range& e) {
60252       {
60253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60254       };
60255     } catch (std::exception& e) {
60256       {
60257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60258       };
60259     } catch (...) {
60260       {
60261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60262       };
60263     }
60264   }
60265   jresult = result;
60266   return jresult;
60267 }
60268
60269
60270 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
60271   float jresult ;
60272   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60273   float result;
60274
60275   arg1 = (Dali::Toolkit::Button *)jarg1;
60276   {
60277     try {
60278       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
60279     } catch (std::out_of_range& e) {
60280       {
60281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60282       };
60283     } catch (std::exception& e) {
60284       {
60285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60286       };
60287     } catch (...) {
60288       {
60289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60290       };
60291     }
60292   }
60293   jresult = result;
60294   return jresult;
60295 }
60296
60297
60298 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
60299   char * jresult ;
60300   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60301   std::string result;
60302
60303   arg1 = (Dali::Toolkit::Button *)jarg1;
60304   {
60305     try {
60306       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
60307     } catch (std::out_of_range& e) {
60308       {
60309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60310       };
60311     } catch (std::exception& e) {
60312       {
60313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60314       };
60315     } catch (...) {
60316       {
60317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60318       };
60319     }
60320   }
60321   jresult = SWIG_csharp_string_callback((&result)->c_str());
60322   return jresult;
60323 }
60324
60325
60326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
60327   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60328   Dali::Actor arg2 ;
60329   Dali::Actor *argp2 ;
60330
60331   arg1 = (Dali::Toolkit::Button *)jarg1;
60332   argp2 = (Dali::Actor *)jarg2;
60333   if (!argp2) {
60334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
60335     return ;
60336   }
60337   arg2 = *argp2;
60338   {
60339     try {
60340       (arg1)->SetLabel(arg2);
60341     } catch (std::out_of_range& e) {
60342       {
60343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60344       };
60345     } catch (std::exception& e) {
60346       {
60347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60348       };
60349     } catch (...) {
60350       {
60351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60352       };
60353     }
60354   }
60355 }
60356
60357
60358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
60359   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60360   Dali::Image arg2 ;
60361   Dali::Image *argp2 ;
60362
60363   arg1 = (Dali::Toolkit::Button *)jarg1;
60364   argp2 = (Dali::Image *)jarg2;
60365   if (!argp2) {
60366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
60367     return ;
60368   }
60369   arg2 = *argp2;
60370   {
60371     try {
60372       (arg1)->SetButtonImage(arg2);
60373     } catch (std::out_of_range& e) {
60374       {
60375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60376       };
60377     } catch (std::exception& e) {
60378       {
60379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60380       };
60381     } catch (...) {
60382       {
60383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60384       };
60385     }
60386   }
60387 }
60388
60389
60390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
60391   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60392   Dali::Image arg2 ;
60393   Dali::Image *argp2 ;
60394
60395   arg1 = (Dali::Toolkit::Button *)jarg1;
60396   argp2 = (Dali::Image *)jarg2;
60397   if (!argp2) {
60398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
60399     return ;
60400   }
60401   arg2 = *argp2;
60402   {
60403     try {
60404       (arg1)->SetSelectedImage(arg2);
60405     } catch (std::out_of_range& e) {
60406       {
60407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60408       };
60409     } catch (std::exception& e) {
60410       {
60411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60412       };
60413     } catch (...) {
60414       {
60415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60416       };
60417     }
60418   }
60419 }
60420
60421
60422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
60423   void * jresult ;
60424   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60425   Dali::Actor result;
60426
60427   arg1 = (Dali::Toolkit::Button *)jarg1;
60428   {
60429     try {
60430       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
60431     } catch (std::out_of_range& e) {
60432       {
60433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60434       };
60435     } catch (std::exception& e) {
60436       {
60437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60438       };
60439     } catch (...) {
60440       {
60441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60442       };
60443     }
60444   }
60445   jresult = new Dali::Actor((const Dali::Actor &)result);
60446   return jresult;
60447 }
60448
60449
60450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
60451   void * jresult ;
60452   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60453   Dali::Actor result;
60454
60455   arg1 = (Dali::Toolkit::Button *)jarg1;
60456   {
60457     try {
60458       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
60459     } catch (std::out_of_range& e) {
60460       {
60461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60462       };
60463     } catch (std::exception& e) {
60464       {
60465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60466       };
60467     } catch (...) {
60468       {
60469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60470       };
60471     }
60472   }
60473   jresult = new Dali::Actor((const Dali::Actor &)result);
60474   return jresult;
60475 }
60476
60477
60478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
60479   void * jresult ;
60480   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60481   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
60482
60483   arg1 = (Dali::Toolkit::Button *)jarg1;
60484   {
60485     try {
60486       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
60487     } catch (std::out_of_range& e) {
60488       {
60489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60490       };
60491     } catch (std::exception& e) {
60492       {
60493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60494       };
60495     } catch (...) {
60496       {
60497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60498       };
60499     }
60500   }
60501   jresult = (void *)result;
60502   return jresult;
60503 }
60504
60505
60506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
60507   void * jresult ;
60508   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60509   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
60510
60511   arg1 = (Dali::Toolkit::Button *)jarg1;
60512   {
60513     try {
60514       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
60515     } catch (std::out_of_range& e) {
60516       {
60517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60518       };
60519     } catch (std::exception& e) {
60520       {
60521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60522       };
60523     } catch (...) {
60524       {
60525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60526       };
60527     }
60528   }
60529   jresult = (void *)result;
60530   return jresult;
60531 }
60532
60533
60534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
60535   void * jresult ;
60536   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60537   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
60538
60539   arg1 = (Dali::Toolkit::Button *)jarg1;
60540   {
60541     try {
60542       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
60543     } catch (std::out_of_range& e) {
60544       {
60545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60546       };
60547     } catch (std::exception& e) {
60548       {
60549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60550       };
60551     } catch (...) {
60552       {
60553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60554       };
60555     }
60556   }
60557   jresult = (void *)result;
60558   return jresult;
60559 }
60560
60561
60562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
60563   void * jresult ;
60564   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60565   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
60566
60567   arg1 = (Dali::Toolkit::Button *)jarg1;
60568   {
60569     try {
60570       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
60571     } catch (std::out_of_range& e) {
60572       {
60573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60574       };
60575     } catch (std::exception& e) {
60576       {
60577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60578       };
60579     } catch (...) {
60580       {
60581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60582       };
60583     }
60584   }
60585   jresult = (void *)result;
60586   return jresult;
60587 }
60588
60589
60590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
60591   void * jresult ;
60592   Dali::Toolkit::CheckBoxButton *result = 0 ;
60593
60594   {
60595     try {
60596       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
60597     } catch (std::out_of_range& e) {
60598       {
60599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60600       };
60601     } catch (std::exception& e) {
60602       {
60603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60604       };
60605     } catch (...) {
60606       {
60607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60608       };
60609     }
60610   }
60611   jresult = (void *)result;
60612   return jresult;
60613 }
60614
60615
60616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
60617   void * jresult ;
60618   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
60619   Dali::Toolkit::CheckBoxButton *result = 0 ;
60620
60621   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
60622   if (!arg1) {
60623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
60624     return 0;
60625   }
60626   {
60627     try {
60628       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
60629     } catch (std::out_of_range& e) {
60630       {
60631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60632       };
60633     } catch (std::exception& e) {
60634       {
60635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60636       };
60637     } catch (...) {
60638       {
60639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60640       };
60641     }
60642   }
60643   jresult = (void *)result;
60644   return jresult;
60645 }
60646
60647
60648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
60649   void * jresult ;
60650   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
60651   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
60652   Dali::Toolkit::CheckBoxButton *result = 0 ;
60653
60654   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
60655   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
60656   if (!arg2) {
60657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
60658     return 0;
60659   }
60660   {
60661     try {
60662       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
60663     } catch (std::out_of_range& e) {
60664       {
60665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60666       };
60667     } catch (std::exception& e) {
60668       {
60669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60670       };
60671     } catch (...) {
60672       {
60673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60674       };
60675     }
60676   }
60677   jresult = (void *)result;
60678   return jresult;
60679 }
60680
60681
60682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
60683   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
60684
60685   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
60686   {
60687     try {
60688       delete arg1;
60689     } catch (std::out_of_range& e) {
60690       {
60691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60692       };
60693     } catch (std::exception& e) {
60694       {
60695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60696       };
60697     } catch (...) {
60698       {
60699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60700       };
60701     }
60702   }
60703 }
60704
60705
60706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
60707   void * jresult ;
60708   Dali::Toolkit::CheckBoxButton result;
60709
60710   {
60711     try {
60712       result = Dali::Toolkit::CheckBoxButton::New();
60713     } catch (std::out_of_range& e) {
60714       {
60715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60716       };
60717     } catch (std::exception& e) {
60718       {
60719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60720       };
60721     } catch (...) {
60722       {
60723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60724       };
60725     }
60726   }
60727   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
60728   return jresult;
60729 }
60730
60731
60732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
60733   void * jresult ;
60734   Dali::BaseHandle arg1 ;
60735   Dali::BaseHandle *argp1 ;
60736   Dali::Toolkit::CheckBoxButton result;
60737
60738   argp1 = (Dali::BaseHandle *)jarg1;
60739   if (!argp1) {
60740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
60741     return 0;
60742   }
60743   arg1 = *argp1;
60744   {
60745     try {
60746       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
60747     } catch (std::out_of_range& e) {
60748       {
60749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60750       };
60751     } catch (std::exception& e) {
60752       {
60753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60754       };
60755     } catch (...) {
60756       {
60757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60758       };
60759     }
60760   }
60761   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
60762   return jresult;
60763 }
60764
60765
60766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
60767   int jresult ;
60768   int result;
60769
60770   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
60771   jresult = (int)result;
60772   return jresult;
60773 }
60774
60775
60776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
60777   int jresult ;
60778   int result;
60779
60780   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
60781   jresult = (int)result;
60782   return jresult;
60783 }
60784
60785
60786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
60787   int jresult ;
60788   int result;
60789
60790   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
60791   jresult = (int)result;
60792   return jresult;
60793 }
60794
60795
60796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
60797   int jresult ;
60798   int result;
60799
60800   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
60801   jresult = (int)result;
60802   return jresult;
60803 }
60804
60805
60806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
60807   int jresult ;
60808   int result;
60809
60810   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
60811   jresult = (int)result;
60812   return jresult;
60813 }
60814
60815
60816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
60817   void * jresult ;
60818   Dali::Toolkit::PushButton::Property *result = 0 ;
60819
60820   {
60821     try {
60822       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
60823     } catch (std::out_of_range& e) {
60824       {
60825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60826       };
60827     } catch (std::exception& e) {
60828       {
60829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60830       };
60831     } catch (...) {
60832       {
60833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60834       };
60835     }
60836   }
60837   jresult = (void *)result;
60838   return jresult;
60839 }
60840
60841
60842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
60843   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
60844
60845   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
60846   {
60847     try {
60848       delete arg1;
60849     } catch (std::out_of_range& e) {
60850       {
60851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60852       };
60853     } catch (std::exception& e) {
60854       {
60855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60856       };
60857     } catch (...) {
60858       {
60859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60860       };
60861     }
60862   }
60863 }
60864
60865
60866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
60867   void * jresult ;
60868   Dali::Toolkit::PushButton *result = 0 ;
60869
60870   {
60871     try {
60872       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
60873     } catch (std::out_of_range& e) {
60874       {
60875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60876       };
60877     } catch (std::exception& e) {
60878       {
60879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60880       };
60881     } catch (...) {
60882       {
60883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60884       };
60885     }
60886   }
60887   jresult = (void *)result;
60888   return jresult;
60889 }
60890
60891
60892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
60893   void * jresult ;
60894   Dali::Toolkit::PushButton *arg1 = 0 ;
60895   Dali::Toolkit::PushButton *result = 0 ;
60896
60897   arg1 = (Dali::Toolkit::PushButton *)jarg1;
60898   if (!arg1) {
60899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
60900     return 0;
60901   }
60902   {
60903     try {
60904       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
60905     } catch (std::out_of_range& e) {
60906       {
60907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60908       };
60909     } catch (std::exception& e) {
60910       {
60911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60912       };
60913     } catch (...) {
60914       {
60915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60916       };
60917     }
60918   }
60919   jresult = (void *)result;
60920   return jresult;
60921 }
60922
60923
60924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
60925   void * jresult ;
60926   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
60927   Dali::Toolkit::PushButton *arg2 = 0 ;
60928   Dali::Toolkit::PushButton *result = 0 ;
60929
60930   arg1 = (Dali::Toolkit::PushButton *)jarg1;
60931   arg2 = (Dali::Toolkit::PushButton *)jarg2;
60932   if (!arg2) {
60933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
60934     return 0;
60935   }
60936   {
60937     try {
60938       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
60939     } catch (std::out_of_range& e) {
60940       {
60941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60942       };
60943     } catch (std::exception& e) {
60944       {
60945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60946       };
60947     } catch (...) {
60948       {
60949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60950       };
60951     }
60952   }
60953   jresult = (void *)result;
60954   return jresult;
60955 }
60956
60957
60958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
60959   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
60960
60961   arg1 = (Dali::Toolkit::PushButton *)jarg1;
60962   {
60963     try {
60964       delete arg1;
60965     } catch (std::out_of_range& e) {
60966       {
60967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60968       };
60969     } catch (std::exception& e) {
60970       {
60971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60972       };
60973     } catch (...) {
60974       {
60975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60976       };
60977     }
60978   }
60979 }
60980
60981
60982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
60983   void * jresult ;
60984   Dali::Toolkit::PushButton result;
60985
60986   {
60987     try {
60988       result = Dali::Toolkit::PushButton::New();
60989     } catch (std::out_of_range& e) {
60990       {
60991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60992       };
60993     } catch (std::exception& e) {
60994       {
60995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60996       };
60997     } catch (...) {
60998       {
60999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61000       };
61001     }
61002   }
61003   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
61004   return jresult;
61005 }
61006
61007
61008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
61009   void * jresult ;
61010   Dali::BaseHandle arg1 ;
61011   Dali::BaseHandle *argp1 ;
61012   Dali::Toolkit::PushButton result;
61013
61014   argp1 = (Dali::BaseHandle *)jarg1;
61015   if (!argp1) {
61016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
61017     return 0;
61018   }
61019   arg1 = *argp1;
61020   {
61021     try {
61022       result = Dali::Toolkit::PushButton::DownCast(arg1);
61023     } catch (std::out_of_range& e) {
61024       {
61025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61026       };
61027     } catch (std::exception& e) {
61028       {
61029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61030       };
61031     } catch (...) {
61032       {
61033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61034       };
61035     }
61036   }
61037   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
61038   return jresult;
61039 }
61040
61041
61042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
61043   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61044   Dali::Image arg2 ;
61045   Dali::Image *argp2 ;
61046
61047   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61048   argp2 = (Dali::Image *)jarg2;
61049   if (!argp2) {
61050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
61051     return ;
61052   }
61053   arg2 = *argp2;
61054   {
61055     try {
61056       (arg1)->SetButtonImage(arg2);
61057     } catch (std::out_of_range& e) {
61058       {
61059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61060       };
61061     } catch (std::exception& e) {
61062       {
61063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61064       };
61065     } catch (...) {
61066       {
61067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61068       };
61069     }
61070   }
61071 }
61072
61073
61074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
61075   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61076   Dali::Actor arg2 ;
61077   Dali::Actor *argp2 ;
61078
61079   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61080   argp2 = (Dali::Actor *)jarg2;
61081   if (!argp2) {
61082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61083     return ;
61084   }
61085   arg2 = *argp2;
61086   {
61087     try {
61088       (arg1)->SetButtonImage(arg2);
61089     } catch (std::out_of_range& e) {
61090       {
61091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61092       };
61093     } catch (std::exception& e) {
61094       {
61095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61096       };
61097     } catch (...) {
61098       {
61099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61100       };
61101     }
61102   }
61103 }
61104
61105
61106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
61107   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61108   Dali::Actor arg2 ;
61109   Dali::Actor *argp2 ;
61110
61111   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61112   argp2 = (Dali::Actor *)jarg2;
61113   if (!argp2) {
61114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61115     return ;
61116   }
61117   arg2 = *argp2;
61118   {
61119     try {
61120       (arg1)->SetBackgroundImage(arg2);
61121     } catch (std::out_of_range& e) {
61122       {
61123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61124       };
61125     } catch (std::exception& e) {
61126       {
61127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61128       };
61129     } catch (...) {
61130       {
61131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61132       };
61133     }
61134   }
61135 }
61136
61137
61138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
61139   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61140   Dali::Image arg2 ;
61141   Dali::Image *argp2 ;
61142
61143   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61144   argp2 = (Dali::Image *)jarg2;
61145   if (!argp2) {
61146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
61147     return ;
61148   }
61149   arg2 = *argp2;
61150   {
61151     try {
61152       (arg1)->SetSelectedImage(arg2);
61153     } catch (std::out_of_range& e) {
61154       {
61155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61156       };
61157     } catch (std::exception& e) {
61158       {
61159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61160       };
61161     } catch (...) {
61162       {
61163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61164       };
61165     }
61166   }
61167 }
61168
61169
61170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
61171   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61172   Dali::Actor arg2 ;
61173   Dali::Actor *argp2 ;
61174
61175   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61176   argp2 = (Dali::Actor *)jarg2;
61177   if (!argp2) {
61178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61179     return ;
61180   }
61181   arg2 = *argp2;
61182   {
61183     try {
61184       (arg1)->SetSelectedImage(arg2);
61185     } catch (std::out_of_range& e) {
61186       {
61187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61188       };
61189     } catch (std::exception& e) {
61190       {
61191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61192       };
61193     } catch (...) {
61194       {
61195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61196       };
61197     }
61198   }
61199 }
61200
61201
61202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
61203   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61204   Dali::Actor arg2 ;
61205   Dali::Actor *argp2 ;
61206
61207   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61208   argp2 = (Dali::Actor *)jarg2;
61209   if (!argp2) {
61210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61211     return ;
61212   }
61213   arg2 = *argp2;
61214   {
61215     try {
61216       (arg1)->SetSelectedBackgroundImage(arg2);
61217     } catch (std::out_of_range& e) {
61218       {
61219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61220       };
61221     } catch (std::exception& e) {
61222       {
61223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61224       };
61225     } catch (...) {
61226       {
61227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61228       };
61229     }
61230   }
61231 }
61232
61233
61234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
61235   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61236   Dali::Actor arg2 ;
61237   Dali::Actor *argp2 ;
61238
61239   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61240   argp2 = (Dali::Actor *)jarg2;
61241   if (!argp2) {
61242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61243     return ;
61244   }
61245   arg2 = *argp2;
61246   {
61247     try {
61248       (arg1)->SetDisabledBackgroundImage(arg2);
61249     } catch (std::out_of_range& e) {
61250       {
61251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61252       };
61253     } catch (std::exception& e) {
61254       {
61255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61256       };
61257     } catch (...) {
61258       {
61259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61260       };
61261     }
61262   }
61263 }
61264
61265
61266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
61267   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61268   Dali::Actor arg2 ;
61269   Dali::Actor *argp2 ;
61270
61271   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61272   argp2 = (Dali::Actor *)jarg2;
61273   if (!argp2) {
61274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61275     return ;
61276   }
61277   arg2 = *argp2;
61278   {
61279     try {
61280       (arg1)->SetDisabledImage(arg2);
61281     } catch (std::out_of_range& e) {
61282       {
61283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61284       };
61285     } catch (std::exception& e) {
61286       {
61287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61288       };
61289     } catch (...) {
61290       {
61291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61292       };
61293     }
61294   }
61295 }
61296
61297
61298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
61299   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61300   Dali::Actor arg2 ;
61301   Dali::Actor *argp2 ;
61302
61303   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61304   argp2 = (Dali::Actor *)jarg2;
61305   if (!argp2) {
61306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61307     return ;
61308   }
61309   arg2 = *argp2;
61310   {
61311     try {
61312       (arg1)->SetDisabledSelectedImage(arg2);
61313     } catch (std::out_of_range& e) {
61314       {
61315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61316       };
61317     } catch (std::exception& e) {
61318       {
61319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61320       };
61321     } catch (...) {
61322       {
61323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61324       };
61325     }
61326   }
61327 }
61328
61329
61330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
61331   void * jresult ;
61332   Dali::Toolkit::RadioButton *result = 0 ;
61333
61334   {
61335     try {
61336       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
61337     } catch (std::out_of_range& e) {
61338       {
61339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61340       };
61341     } catch (std::exception& e) {
61342       {
61343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61344       };
61345     } catch (...) {
61346       {
61347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61348       };
61349     }
61350   }
61351   jresult = (void *)result;
61352   return jresult;
61353 }
61354
61355
61356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
61357   void * jresult ;
61358   Dali::Toolkit::RadioButton *arg1 = 0 ;
61359   Dali::Toolkit::RadioButton *result = 0 ;
61360
61361   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
61362   if (!arg1) {
61363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
61364     return 0;
61365   }
61366   {
61367     try {
61368       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
61369     } catch (std::out_of_range& e) {
61370       {
61371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61372       };
61373     } catch (std::exception& e) {
61374       {
61375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61376       };
61377     } catch (...) {
61378       {
61379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61380       };
61381     }
61382   }
61383   jresult = (void *)result;
61384   return jresult;
61385 }
61386
61387
61388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
61389   void * jresult ;
61390   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
61391   Dali::Toolkit::RadioButton *arg2 = 0 ;
61392   Dali::Toolkit::RadioButton *result = 0 ;
61393
61394   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
61395   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
61396   if (!arg2) {
61397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
61398     return 0;
61399   }
61400   {
61401     try {
61402       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
61403     } catch (std::out_of_range& e) {
61404       {
61405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61406       };
61407     } catch (std::exception& e) {
61408       {
61409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61410       };
61411     } catch (...) {
61412       {
61413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61414       };
61415     }
61416   }
61417   jresult = (void *)result;
61418   return jresult;
61419 }
61420
61421
61422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
61423   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
61424
61425   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
61426   {
61427     try {
61428       delete arg1;
61429     } catch (std::out_of_range& e) {
61430       {
61431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61432       };
61433     } catch (std::exception& e) {
61434       {
61435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61436       };
61437     } catch (...) {
61438       {
61439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61440       };
61441     }
61442   }
61443 }
61444
61445
61446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
61447   void * jresult ;
61448   Dali::Toolkit::RadioButton result;
61449
61450   {
61451     try {
61452       result = Dali::Toolkit::RadioButton::New();
61453     } catch (std::out_of_range& e) {
61454       {
61455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61456       };
61457     } catch (std::exception& e) {
61458       {
61459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61460       };
61461     } catch (...) {
61462       {
61463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61464       };
61465     }
61466   }
61467   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
61468   return jresult;
61469 }
61470
61471
61472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
61473   void * jresult ;
61474   std::string *arg1 = 0 ;
61475   Dali::Toolkit::RadioButton result;
61476
61477   if (!jarg1) {
61478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61479     return 0;
61480   }
61481   std::string arg1_str(jarg1);
61482   arg1 = &arg1_str;
61483   {
61484     try {
61485       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
61486     } catch (std::out_of_range& e) {
61487       {
61488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61489       };
61490     } catch (std::exception& e) {
61491       {
61492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61493       };
61494     } catch (...) {
61495       {
61496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61497       };
61498     }
61499   }
61500   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
61501
61502   //argout typemap for const std::string&
61503
61504   return jresult;
61505 }
61506
61507
61508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
61509   void * jresult ;
61510   Dali::BaseHandle arg1 ;
61511   Dali::BaseHandle *argp1 ;
61512   Dali::Toolkit::RadioButton result;
61513
61514   argp1 = (Dali::BaseHandle *)jarg1;
61515   if (!argp1) {
61516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
61517     return 0;
61518   }
61519   arg1 = *argp1;
61520   {
61521     try {
61522       result = Dali::Toolkit::RadioButton::DownCast(arg1);
61523     } catch (std::out_of_range& e) {
61524       {
61525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61526       };
61527     } catch (std::exception& e) {
61528       {
61529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61530       };
61531     } catch (...) {
61532       {
61533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61534       };
61535     }
61536   }
61537   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
61538   return jresult;
61539 }
61540
61541
61542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
61543   int jresult ;
61544   int result;
61545
61546   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
61547   jresult = (int)result;
61548   return jresult;
61549 }
61550
61551
61552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
61553   int jresult ;
61554   int result;
61555
61556   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
61557   jresult = (int)result;
61558   return jresult;
61559 }
61560
61561
61562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
61563   int jresult ;
61564   int result;
61565
61566   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
61567   jresult = (int)result;
61568   return jresult;
61569 }
61570
61571
61572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
61573   int jresult ;
61574   int result;
61575
61576   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
61577   jresult = (int)result;
61578   return jresult;
61579 }
61580
61581
61582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
61583   int jresult ;
61584   int result;
61585
61586   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
61587   jresult = (int)result;
61588   return jresult;
61589 }
61590
61591
61592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
61593   int jresult ;
61594   int result;
61595
61596   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
61597   jresult = (int)result;
61598   return jresult;
61599 }
61600
61601
61602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
61603   void * jresult ;
61604   Dali::Toolkit::FlexContainer::Property *result = 0 ;
61605
61606   {
61607     try {
61608       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
61609     } catch (std::out_of_range& e) {
61610       {
61611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61612       };
61613     } catch (std::exception& e) {
61614       {
61615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61616       };
61617     } catch (...) {
61618       {
61619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61620       };
61621     }
61622   }
61623   jresult = (void *)result;
61624   return jresult;
61625 }
61626
61627
61628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
61629   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
61630
61631   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
61632   {
61633     try {
61634       delete arg1;
61635     } catch (std::out_of_range& e) {
61636       {
61637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61638       };
61639     } catch (std::exception& e) {
61640       {
61641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61642       };
61643     } catch (...) {
61644       {
61645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61646       };
61647     }
61648   }
61649 }
61650
61651
61652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
61653   int jresult ;
61654   int result;
61655
61656   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
61657   jresult = (int)result;
61658   return jresult;
61659 }
61660
61661
61662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
61663   int jresult ;
61664   int result;
61665
61666   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
61667   jresult = (int)result;
61668   return jresult;
61669 }
61670
61671
61672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
61673   int jresult ;
61674   int result;
61675
61676   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
61677   jresult = (int)result;
61678   return jresult;
61679 }
61680
61681
61682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
61683   void * jresult ;
61684   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
61685
61686   {
61687     try {
61688       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
61689     } catch (std::out_of_range& e) {
61690       {
61691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61692       };
61693     } catch (std::exception& e) {
61694       {
61695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61696       };
61697     } catch (...) {
61698       {
61699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61700       };
61701     }
61702   }
61703   jresult = (void *)result;
61704   return jresult;
61705 }
61706
61707
61708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
61709   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
61710
61711   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
61712   {
61713     try {
61714       delete arg1;
61715     } catch (std::out_of_range& e) {
61716       {
61717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61718       };
61719     } catch (std::exception& e) {
61720       {
61721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61722       };
61723     } catch (...) {
61724       {
61725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61726       };
61727     }
61728   }
61729 }
61730
61731
61732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
61733   void * jresult ;
61734   Dali::Toolkit::FlexContainer *result = 0 ;
61735
61736   {
61737     try {
61738       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
61739     } catch (std::out_of_range& e) {
61740       {
61741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61742       };
61743     } catch (std::exception& e) {
61744       {
61745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61746       };
61747     } catch (...) {
61748       {
61749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61750       };
61751     }
61752   }
61753   jresult = (void *)result;
61754   return jresult;
61755 }
61756
61757
61758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
61759   void * jresult ;
61760   Dali::Toolkit::FlexContainer *arg1 = 0 ;
61761   Dali::Toolkit::FlexContainer *result = 0 ;
61762
61763   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
61764   if (!arg1) {
61765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
61766     return 0;
61767   }
61768   {
61769     try {
61770       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
61771     } catch (std::out_of_range& e) {
61772       {
61773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61774       };
61775     } catch (std::exception& e) {
61776       {
61777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61778       };
61779     } catch (...) {
61780       {
61781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61782       };
61783     }
61784   }
61785   jresult = (void *)result;
61786   return jresult;
61787 }
61788
61789
61790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
61791   void * jresult ;
61792   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
61793   Dali::Toolkit::FlexContainer *arg2 = 0 ;
61794   Dali::Toolkit::FlexContainer *result = 0 ;
61795
61796   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
61797   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
61798   if (!arg2) {
61799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
61800     return 0;
61801   }
61802   {
61803     try {
61804       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
61805     } catch (std::out_of_range& e) {
61806       {
61807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61808       };
61809     } catch (std::exception& e) {
61810       {
61811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61812       };
61813     } catch (...) {
61814       {
61815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61816       };
61817     }
61818   }
61819   jresult = (void *)result;
61820   return jresult;
61821 }
61822
61823
61824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
61825   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
61826
61827   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
61828   {
61829     try {
61830       delete arg1;
61831     } catch (std::out_of_range& e) {
61832       {
61833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61834       };
61835     } catch (std::exception& e) {
61836       {
61837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61838       };
61839     } catch (...) {
61840       {
61841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61842       };
61843     }
61844   }
61845 }
61846
61847
61848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
61849   void * jresult ;
61850   Dali::Toolkit::FlexContainer result;
61851
61852   {
61853     try {
61854       result = Dali::Toolkit::FlexContainer::New();
61855     } catch (std::out_of_range& e) {
61856       {
61857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61858       };
61859     } catch (std::exception& e) {
61860       {
61861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61862       };
61863     } catch (...) {
61864       {
61865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61866       };
61867     }
61868   }
61869   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
61870   return jresult;
61871 }
61872
61873
61874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
61875   void * jresult ;
61876   Dali::BaseHandle arg1 ;
61877   Dali::BaseHandle *argp1 ;
61878   Dali::Toolkit::FlexContainer result;
61879
61880   argp1 = (Dali::BaseHandle *)jarg1;
61881   if (!argp1) {
61882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
61883     return 0;
61884   }
61885   arg1 = *argp1;
61886   {
61887     try {
61888       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
61889     } catch (std::out_of_range& e) {
61890       {
61891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61892       };
61893     } catch (std::exception& e) {
61894       {
61895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61896       };
61897     } catch (...) {
61898       {
61899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61900       };
61901     }
61902   }
61903   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
61904   return jresult;
61905 }
61906
61907
61908 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
61909   int jresult ;
61910   int result;
61911
61912   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
61913   jresult = (int)result;
61914   return jresult;
61915 }
61916
61917
61918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
61919   int jresult ;
61920   int result;
61921
61922   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
61923   jresult = (int)result;
61924   return jresult;
61925 }
61926
61927
61928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
61929   int jresult ;
61930   int result;
61931
61932   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
61933   jresult = (int)result;
61934   return jresult;
61935 }
61936
61937
61938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
61939   int jresult ;
61940   int result;
61941
61942   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
61943   jresult = (int)result;
61944   return jresult;
61945 }
61946
61947
61948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
61949   void * jresult ;
61950   Dali::Toolkit::ImageView::Property *result = 0 ;
61951
61952   {
61953     try {
61954       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
61955     } catch (std::out_of_range& e) {
61956       {
61957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61958       };
61959     } catch (std::exception& e) {
61960       {
61961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61962       };
61963     } catch (...) {
61964       {
61965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61966       };
61967     }
61968   }
61969   jresult = (void *)result;
61970   return jresult;
61971 }
61972
61973
61974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
61975   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
61976
61977   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
61978   {
61979     try {
61980       delete arg1;
61981     } catch (std::out_of_range& e) {
61982       {
61983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61984       };
61985     } catch (std::exception& e) {
61986       {
61987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61988       };
61989     } catch (...) {
61990       {
61991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61992       };
61993     }
61994   }
61995 }
61996
61997
61998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
61999   void * jresult ;
62000   Dali::Toolkit::ImageView *result = 0 ;
62001
62002   {
62003     try {
62004       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
62005     } catch (std::out_of_range& e) {
62006       {
62007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62008       };
62009     } catch (std::exception& e) {
62010       {
62011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62012       };
62013     } catch (...) {
62014       {
62015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62016       };
62017     }
62018   }
62019   jresult = (void *)result;
62020   return jresult;
62021 }
62022
62023
62024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
62025   void * jresult ;
62026   Dali::Toolkit::ImageView result;
62027
62028   {
62029     try {
62030       result = Dali::Toolkit::ImageView::New();
62031     } catch (std::out_of_range& e) {
62032       {
62033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62034       };
62035     } catch (std::exception& e) {
62036       {
62037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62038       };
62039     } catch (...) {
62040       {
62041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62042       };
62043     }
62044   }
62045   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
62046   return jresult;
62047 }
62048
62049
62050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
62051   void * jresult ;
62052   Dali::Image arg1 ;
62053   Dali::Image *argp1 ;
62054   Dali::Toolkit::ImageView result;
62055
62056   argp1 = (Dali::Image *)jarg1;
62057   if (!argp1) {
62058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
62059     return 0;
62060   }
62061   arg1 = *argp1;
62062   {
62063     try {
62064       result = Dali::Toolkit::ImageView::New(arg1);
62065     } catch (std::out_of_range& e) {
62066       {
62067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62068       };
62069     } catch (std::exception& e) {
62070       {
62071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62072       };
62073     } catch (...) {
62074       {
62075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62076       };
62077     }
62078   }
62079   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
62080   return jresult;
62081 }
62082
62083
62084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
62085   void * jresult ;
62086   std::string *arg1 = 0 ;
62087   Dali::Toolkit::ImageView result;
62088
62089   if (!jarg1) {
62090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62091     return 0;
62092   }
62093   std::string arg1_str(jarg1);
62094   arg1 = &arg1_str;
62095   {
62096     try {
62097       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
62098     } catch (std::out_of_range& e) {
62099       {
62100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62101       };
62102     } catch (std::exception& e) {
62103       {
62104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62105       };
62106     } catch (...) {
62107       {
62108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62109       };
62110     }
62111   }
62112   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
62113
62114   //argout typemap for const std::string&
62115
62116   return jresult;
62117 }
62118
62119
62120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
62121   void * jresult ;
62122   std::string *arg1 = 0 ;
62123   Dali::ImageDimensions arg2 ;
62124   Dali::ImageDimensions *argp2 ;
62125   Dali::Toolkit::ImageView result;
62126
62127   if (!jarg1) {
62128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62129     return 0;
62130   }
62131   std::string arg1_str(jarg1);
62132   arg1 = &arg1_str;
62133   argp2 = (Dali::ImageDimensions *)jarg2;
62134   if (!argp2) {
62135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
62136     return 0;
62137   }
62138   arg2 = *argp2;
62139   {
62140     try {
62141       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
62142     } catch (std::out_of_range& e) {
62143       {
62144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62145       };
62146     } catch (std::exception& e) {
62147       {
62148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62149       };
62150     } catch (...) {
62151       {
62152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62153       };
62154     }
62155   }
62156   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
62157
62158   //argout typemap for const std::string&
62159
62160   return jresult;
62161 }
62162
62163
62164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
62165   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62166
62167   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62168   {
62169     try {
62170       delete arg1;
62171     } catch (std::out_of_range& e) {
62172       {
62173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62174       };
62175     } catch (std::exception& e) {
62176       {
62177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62178       };
62179     } catch (...) {
62180       {
62181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62182       };
62183     }
62184   }
62185 }
62186
62187
62188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
62189   void * jresult ;
62190   Dali::Toolkit::ImageView *arg1 = 0 ;
62191   Dali::Toolkit::ImageView *result = 0 ;
62192
62193   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62194   if (!arg1) {
62195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
62196     return 0;
62197   }
62198   {
62199     try {
62200       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
62201     } catch (std::out_of_range& e) {
62202       {
62203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62204       };
62205     } catch (std::exception& e) {
62206       {
62207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62208       };
62209     } catch (...) {
62210       {
62211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62212       };
62213     }
62214   }
62215   jresult = (void *)result;
62216   return jresult;
62217 }
62218
62219
62220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
62221   void * jresult ;
62222   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62223   Dali::Toolkit::ImageView *arg2 = 0 ;
62224   Dali::Toolkit::ImageView *result = 0 ;
62225
62226   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62227   arg2 = (Dali::Toolkit::ImageView *)jarg2;
62228   if (!arg2) {
62229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
62230     return 0;
62231   }
62232   {
62233     try {
62234       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
62235     } catch (std::out_of_range& e) {
62236       {
62237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62238       };
62239     } catch (std::exception& e) {
62240       {
62241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62242       };
62243     } catch (...) {
62244       {
62245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62246       };
62247     }
62248   }
62249   jresult = (void *)result;
62250   return jresult;
62251 }
62252
62253
62254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
62255   void * jresult ;
62256   Dali::BaseHandle arg1 ;
62257   Dali::BaseHandle *argp1 ;
62258   Dali::Toolkit::ImageView result;
62259
62260   argp1 = (Dali::BaseHandle *)jarg1;
62261   if (!argp1) {
62262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62263     return 0;
62264   }
62265   arg1 = *argp1;
62266   {
62267     try {
62268       result = Dali::Toolkit::ImageView::DownCast(arg1);
62269     } catch (std::out_of_range& e) {
62270       {
62271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62272       };
62273     } catch (std::exception& e) {
62274       {
62275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62276       };
62277     } catch (...) {
62278       {
62279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62280       };
62281     }
62282   }
62283   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
62284   return jresult;
62285 }
62286
62287
62288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
62289   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62290   Dali::Image arg2 ;
62291   Dali::Image *argp2 ;
62292
62293   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62294   argp2 = (Dali::Image *)jarg2;
62295   if (!argp2) {
62296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
62297     return ;
62298   }
62299   arg2 = *argp2;
62300   {
62301     try {
62302       (arg1)->SetImage(arg2);
62303     } catch (std::out_of_range& e) {
62304       {
62305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62306       };
62307     } catch (std::exception& e) {
62308       {
62309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62310       };
62311     } catch (...) {
62312       {
62313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62314       };
62315     }
62316   }
62317 }
62318
62319
62320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
62321   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62322   std::string *arg2 = 0 ;
62323
62324   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62325   if (!jarg2) {
62326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62327     return ;
62328   }
62329   std::string arg2_str(jarg2);
62330   arg2 = &arg2_str;
62331   {
62332     try {
62333       (arg1)->SetImage((std::string const &)*arg2);
62334     } catch (std::out_of_range& e) {
62335       {
62336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62337       };
62338     } catch (std::exception& e) {
62339       {
62340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62341       };
62342     } catch (...) {
62343       {
62344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62345       };
62346     }
62347   }
62348
62349   //argout typemap for const std::string&
62350
62351 }
62352
62353
62354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
62355   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62356   std::string *arg2 = 0 ;
62357   Dali::ImageDimensions arg3 ;
62358   Dali::ImageDimensions *argp3 ;
62359
62360   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62361   if (!jarg2) {
62362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62363     return ;
62364   }
62365   std::string arg2_str(jarg2);
62366   arg2 = &arg2_str;
62367   argp3 = (Dali::ImageDimensions *)jarg3;
62368   if (!argp3) {
62369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
62370     return ;
62371   }
62372   arg3 = *argp3;
62373   {
62374     try {
62375       (arg1)->SetImage((std::string const &)*arg2,arg3);
62376     } catch (std::out_of_range& e) {
62377       {
62378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62379       };
62380     } catch (std::exception& e) {
62381       {
62382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62383       };
62384     } catch (...) {
62385       {
62386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62387       };
62388     }
62389   }
62390
62391   //argout typemap for const std::string&
62392
62393 }
62394
62395
62396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
62397   void * jresult ;
62398   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62399   Dali::Image result;
62400
62401   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62402   {
62403     try {
62404       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
62405     } catch (std::out_of_range& e) {
62406       {
62407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62408       };
62409     } catch (std::exception& e) {
62410       {
62411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62412       };
62413     } catch (...) {
62414       {
62415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62416       };
62417     }
62418   }
62419   jresult = new Dali::Image((const Dali::Image &)result);
62420   return jresult;
62421 }
62422
62423
62424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
62425   int jresult ;
62426   int result;
62427
62428   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
62429   jresult = (int)result;
62430   return jresult;
62431 }
62432
62433
62434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
62435   int jresult ;
62436   int result;
62437
62438   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
62439   jresult = (int)result;
62440   return jresult;
62441 }
62442
62443
62444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
62445   int jresult ;
62446   int result;
62447
62448   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
62449   jresult = (int)result;
62450   return jresult;
62451 }
62452
62453
62454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
62455   int jresult ;
62456   int result;
62457
62458   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
62459   jresult = (int)result;
62460   return jresult;
62461 }
62462
62463
62464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
62465   int jresult ;
62466   int result;
62467
62468   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
62469   jresult = (int)result;
62470   return jresult;
62471 }
62472
62473
62474 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
62475   int jresult ;
62476   int result;
62477
62478   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
62479   jresult = (int)result;
62480   return jresult;
62481 }
62482
62483
62484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
62485   int jresult ;
62486   int result;
62487
62488   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
62489   jresult = (int)result;
62490   return jresult;
62491 }
62492
62493
62494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
62495   int jresult ;
62496   int result;
62497
62498   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
62499   jresult = (int)result;
62500   return jresult;
62501 }
62502
62503
62504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
62505   void * jresult ;
62506   Dali::Toolkit::Model3dView::Property *result = 0 ;
62507
62508   {
62509     try {
62510       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
62511     } catch (std::out_of_range& e) {
62512       {
62513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62514       };
62515     } catch (std::exception& e) {
62516       {
62517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62518       };
62519     } catch (...) {
62520       {
62521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62522       };
62523     }
62524   }
62525   jresult = (void *)result;
62526   return jresult;
62527 }
62528
62529
62530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
62531   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
62532
62533   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
62534   {
62535     try {
62536       delete arg1;
62537     } catch (std::out_of_range& e) {
62538       {
62539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62540       };
62541     } catch (std::exception& e) {
62542       {
62543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62544       };
62545     } catch (...) {
62546       {
62547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62548       };
62549     }
62550   }
62551 }
62552
62553
62554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
62555   void * jresult ;
62556   Dali::Toolkit::Model3dView result;
62557
62558   {
62559     try {
62560       result = Dali::Toolkit::Model3dView::New();
62561     } catch (std::out_of_range& e) {
62562       {
62563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62564       };
62565     } catch (std::exception& e) {
62566       {
62567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62568       };
62569     } catch (...) {
62570       {
62571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62572       };
62573     }
62574   }
62575   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
62576   return jresult;
62577 }
62578
62579
62580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
62581   void * jresult ;
62582   std::string *arg1 = 0 ;
62583   std::string *arg2 = 0 ;
62584   std::string *arg3 = 0 ;
62585   Dali::Toolkit::Model3dView result;
62586
62587   if (!jarg1) {
62588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62589     return 0;
62590   }
62591   std::string arg1_str(jarg1);
62592   arg1 = &arg1_str;
62593   if (!jarg2) {
62594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62595     return 0;
62596   }
62597   std::string arg2_str(jarg2);
62598   arg2 = &arg2_str;
62599   if (!jarg3) {
62600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62601     return 0;
62602   }
62603   std::string arg3_str(jarg3);
62604   arg3 = &arg3_str;
62605   {
62606     try {
62607       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
62608     } catch (std::out_of_range& e) {
62609       {
62610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62611       };
62612     } catch (std::exception& e) {
62613       {
62614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62615       };
62616     } catch (...) {
62617       {
62618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62619       };
62620     }
62621   }
62622   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
62623
62624   //argout typemap for const std::string&
62625
62626
62627   //argout typemap for const std::string&
62628
62629
62630   //argout typemap for const std::string&
62631
62632   return jresult;
62633 }
62634
62635
62636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
62637   void * jresult ;
62638   Dali::Toolkit::Model3dView *result = 0 ;
62639
62640   {
62641     try {
62642       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
62643     } catch (std::out_of_range& e) {
62644       {
62645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62646       };
62647     } catch (std::exception& e) {
62648       {
62649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62650       };
62651     } catch (...) {
62652       {
62653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62654       };
62655     }
62656   }
62657   jresult = (void *)result;
62658   return jresult;
62659 }
62660
62661
62662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
62663   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
62664
62665   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
62666   {
62667     try {
62668       delete arg1;
62669     } catch (std::out_of_range& e) {
62670       {
62671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62672       };
62673     } catch (std::exception& e) {
62674       {
62675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62676       };
62677     } catch (...) {
62678       {
62679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62680       };
62681     }
62682   }
62683 }
62684
62685
62686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
62687   void * jresult ;
62688   Dali::Toolkit::Model3dView *arg1 = 0 ;
62689   Dali::Toolkit::Model3dView *result = 0 ;
62690
62691   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
62692   if (!arg1) {
62693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
62694     return 0;
62695   }
62696   {
62697     try {
62698       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
62699     } catch (std::out_of_range& e) {
62700       {
62701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62702       };
62703     } catch (std::exception& e) {
62704       {
62705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62706       };
62707     } catch (...) {
62708       {
62709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62710       };
62711     }
62712   }
62713   jresult = (void *)result;
62714   return jresult;
62715 }
62716
62717
62718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
62719   void * jresult ;
62720   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
62721   Dali::Toolkit::Model3dView *arg2 = 0 ;
62722   Dali::Toolkit::Model3dView *result = 0 ;
62723
62724   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
62725   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
62726   if (!arg2) {
62727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
62728     return 0;
62729   }
62730   {
62731     try {
62732       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
62733     } catch (std::out_of_range& e) {
62734       {
62735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62736       };
62737     } catch (std::exception& e) {
62738       {
62739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62740       };
62741     } catch (...) {
62742       {
62743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62744       };
62745     }
62746   }
62747   jresult = (void *)result;
62748   return jresult;
62749 }
62750
62751
62752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
62753   void * jresult ;
62754   Dali::BaseHandle arg1 ;
62755   Dali::BaseHandle *argp1 ;
62756   Dali::Toolkit::Model3dView result;
62757
62758   argp1 = (Dali::BaseHandle *)jarg1;
62759   if (!argp1) {
62760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62761     return 0;
62762   }
62763   arg1 = *argp1;
62764   {
62765     try {
62766       result = Dali::Toolkit::Model3dView::DownCast(arg1);
62767     } catch (std::out_of_range& e) {
62768       {
62769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62770       };
62771     } catch (std::exception& e) {
62772       {
62773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62774       };
62775     } catch (...) {
62776       {
62777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62778       };
62779     }
62780   }
62781   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
62782   return jresult;
62783 }
62784
62785
62786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
62787   int jresult ;
62788   int result;
62789
62790   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
62791   jresult = (int)result;
62792   return jresult;
62793 }
62794
62795
62796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
62797   int jresult ;
62798   int result;
62799
62800   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
62801   jresult = (int)result;
62802   return jresult;
62803 }
62804
62805
62806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
62807   int jresult ;
62808   int result;
62809
62810   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
62811   jresult = (int)result;
62812   return jresult;
62813 }
62814
62815
62816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
62817   int jresult ;
62818   int result;
62819
62820   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
62821   jresult = (int)result;
62822   return jresult;
62823 }
62824
62825
62826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
62827   int jresult ;
62828   int result;
62829
62830   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
62831   jresult = (int)result;
62832   return jresult;
62833 }
62834
62835
62836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
62837   int jresult ;
62838   int result;
62839
62840   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
62841   jresult = (int)result;
62842   return jresult;
62843 }
62844
62845
62846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
62847   int jresult ;
62848   int result;
62849
62850   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
62851   jresult = (int)result;
62852   return jresult;
62853 }
62854
62855
62856 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
62857   int jresult ;
62858   int result;
62859
62860   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
62861   jresult = (int)result;
62862   return jresult;
62863 }
62864
62865
62866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
62867   int jresult ;
62868   int result;
62869
62870   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
62871   jresult = (int)result;
62872   return jresult;
62873 }
62874
62875
62876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
62877   void * jresult ;
62878   Dali::Toolkit::ScrollBar::Property *result = 0 ;
62879
62880   {
62881     try {
62882       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
62883     } catch (std::out_of_range& e) {
62884       {
62885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62886       };
62887     } catch (std::exception& e) {
62888       {
62889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62890       };
62891     } catch (...) {
62892       {
62893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62894       };
62895     }
62896   }
62897   jresult = (void *)result;
62898   return jresult;
62899 }
62900
62901
62902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
62903   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
62904
62905   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
62906   {
62907     try {
62908       delete arg1;
62909     } catch (std::out_of_range& e) {
62910       {
62911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62912       };
62913     } catch (std::exception& e) {
62914       {
62915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62916       };
62917     } catch (...) {
62918       {
62919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62920       };
62921     }
62922   }
62923 }
62924
62925
62926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
62927   void * jresult ;
62928   Dali::Toolkit::ScrollBar *result = 0 ;
62929
62930   {
62931     try {
62932       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
62933     } catch (std::out_of_range& e) {
62934       {
62935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62936       };
62937     } catch (std::exception& e) {
62938       {
62939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62940       };
62941     } catch (...) {
62942       {
62943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62944       };
62945     }
62946   }
62947   jresult = (void *)result;
62948   return jresult;
62949 }
62950
62951
62952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
62953   void * jresult ;
62954   Dali::Toolkit::ScrollBar *arg1 = 0 ;
62955   Dali::Toolkit::ScrollBar *result = 0 ;
62956
62957   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
62958   if (!arg1) {
62959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
62960     return 0;
62961   }
62962   {
62963     try {
62964       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
62965     } catch (std::out_of_range& e) {
62966       {
62967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62968       };
62969     } catch (std::exception& e) {
62970       {
62971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62972       };
62973     } catch (...) {
62974       {
62975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62976       };
62977     }
62978   }
62979   jresult = (void *)result;
62980   return jresult;
62981 }
62982
62983
62984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
62985   void * jresult ;
62986   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
62987   Dali::Toolkit::ScrollBar *arg2 = 0 ;
62988   Dali::Toolkit::ScrollBar *result = 0 ;
62989
62990   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
62991   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
62992   if (!arg2) {
62993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
62994     return 0;
62995   }
62996   {
62997     try {
62998       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
62999     } catch (std::out_of_range& e) {
63000       {
63001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63002       };
63003     } catch (std::exception& e) {
63004       {
63005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63006       };
63007     } catch (...) {
63008       {
63009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63010       };
63011     }
63012   }
63013   jresult = (void *)result;
63014   return jresult;
63015 }
63016
63017
63018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
63019   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63020
63021   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63022   {
63023     try {
63024       delete arg1;
63025     } catch (std::out_of_range& e) {
63026       {
63027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63028       };
63029     } catch (std::exception& e) {
63030       {
63031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63032       };
63033     } catch (...) {
63034       {
63035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63036       };
63037     }
63038   }
63039 }
63040
63041
63042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
63043   void * jresult ;
63044   Dali::Toolkit::ScrollBar::Direction arg1 ;
63045   Dali::Toolkit::ScrollBar result;
63046
63047   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
63048   {
63049     try {
63050       result = Dali::Toolkit::ScrollBar::New(arg1);
63051     } catch (std::out_of_range& e) {
63052       {
63053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63054       };
63055     } catch (std::exception& e) {
63056       {
63057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63058       };
63059     } catch (...) {
63060       {
63061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63062       };
63063     }
63064   }
63065   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
63066   return jresult;
63067 }
63068
63069
63070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
63071   void * jresult ;
63072   Dali::Toolkit::ScrollBar result;
63073
63074   {
63075     try {
63076       result = Dali::Toolkit::ScrollBar::New();
63077     } catch (std::out_of_range& e) {
63078       {
63079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63080       };
63081     } catch (std::exception& e) {
63082       {
63083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63084       };
63085     } catch (...) {
63086       {
63087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63088       };
63089     }
63090   }
63091   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
63092   return jresult;
63093 }
63094
63095
63096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
63097   void * jresult ;
63098   Dali::BaseHandle arg1 ;
63099   Dali::BaseHandle *argp1 ;
63100   Dali::Toolkit::ScrollBar result;
63101
63102   argp1 = (Dali::BaseHandle *)jarg1;
63103   if (!argp1) {
63104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63105     return 0;
63106   }
63107   arg1 = *argp1;
63108   {
63109     try {
63110       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
63111     } catch (std::out_of_range& e) {
63112       {
63113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63114       };
63115     } catch (std::exception& e) {
63116       {
63117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63118       };
63119     } catch (...) {
63120       {
63121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63122       };
63123     }
63124   }
63125   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
63126   return jresult;
63127 }
63128
63129
63130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
63131   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63132   Dali::Handle arg2 ;
63133   Dali::Property::Index arg3 ;
63134   Dali::Property::Index arg4 ;
63135   Dali::Property::Index arg5 ;
63136   Dali::Property::Index arg6 ;
63137   Dali::Handle *argp2 ;
63138
63139   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63140   argp2 = (Dali::Handle *)jarg2;
63141   if (!argp2) {
63142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
63143     return ;
63144   }
63145   arg2 = *argp2;
63146   arg3 = (Dali::Property::Index)jarg3;
63147   arg4 = (Dali::Property::Index)jarg4;
63148   arg5 = (Dali::Property::Index)jarg5;
63149   arg6 = (Dali::Property::Index)jarg6;
63150   {
63151     try {
63152       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
63153     } catch (std::out_of_range& e) {
63154       {
63155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63156       };
63157     } catch (std::exception& e) {
63158       {
63159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63160       };
63161     } catch (...) {
63162       {
63163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63164       };
63165     }
63166   }
63167 }
63168
63169
63170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
63171   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63172   Dali::Actor arg2 ;
63173   Dali::Actor *argp2 ;
63174
63175   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63176   argp2 = (Dali::Actor *)jarg2;
63177   if (!argp2) {
63178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
63179     return ;
63180   }
63181   arg2 = *argp2;
63182   {
63183     try {
63184       (arg1)->SetScrollIndicator(arg2);
63185     } catch (std::out_of_range& e) {
63186       {
63187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63188       };
63189     } catch (std::exception& e) {
63190       {
63191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63192       };
63193     } catch (...) {
63194       {
63195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63196       };
63197     }
63198   }
63199 }
63200
63201
63202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
63203   void * jresult ;
63204   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63205   Dali::Actor result;
63206
63207   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63208   {
63209     try {
63210       result = (arg1)->GetScrollIndicator();
63211     } catch (std::out_of_range& e) {
63212       {
63213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63214       };
63215     } catch (std::exception& e) {
63216       {
63217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63218       };
63219     } catch (...) {
63220       {
63221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63222       };
63223     }
63224   }
63225   jresult = new Dali::Actor((const Dali::Actor &)result);
63226   return jresult;
63227 }
63228
63229
63230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
63231   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63232   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
63233
63234   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63235   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
63236   if (!arg2) {
63237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
63238     return ;
63239   }
63240   {
63241     try {
63242       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
63243     } catch (std::out_of_range& e) {
63244       {
63245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63246       };
63247     } catch (std::exception& e) {
63248       {
63249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63250       };
63251     } catch (...) {
63252       {
63253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63254       };
63255     }
63256   }
63257 }
63258
63259
63260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
63261   void * jresult ;
63262   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63263   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > result;
63264
63265   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63266   {
63267     try {
63268       result = ((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollPositionIntervals();
63269     } catch (std::out_of_range& e) {
63270       {
63271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63272       };
63273     } catch (std::exception& e) {
63274       {
63275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63276       };
63277     } catch (...) {
63278       {
63279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63280       };
63281     }
63282   }
63283   jresult = new Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true >((const Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > &)result);
63284   return jresult;
63285 }
63286
63287
63288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
63289   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63290   Dali::Toolkit::ScrollBar::Direction arg2 ;
63291
63292   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63293   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
63294   {
63295     try {
63296       (arg1)->SetScrollDirection(arg2);
63297     } catch (std::out_of_range& e) {
63298       {
63299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63300       };
63301     } catch (std::exception& e) {
63302       {
63303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63304       };
63305     } catch (...) {
63306       {
63307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63308       };
63309     }
63310   }
63311 }
63312
63313
63314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
63315   int jresult ;
63316   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63317   Dali::Toolkit::ScrollBar::Direction result;
63318
63319   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63320   {
63321     try {
63322       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
63323     } catch (std::out_of_range& e) {
63324       {
63325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63326       };
63327     } catch (std::exception& e) {
63328       {
63329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63330       };
63331     } catch (...) {
63332       {
63333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63334       };
63335     }
63336   }
63337   jresult = (int)result;
63338   return jresult;
63339 }
63340
63341
63342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
63343   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63344   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
63345
63346   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63347   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
63348   {
63349     try {
63350       (arg1)->SetIndicatorHeightPolicy(arg2);
63351     } catch (std::out_of_range& e) {
63352       {
63353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63354       };
63355     } catch (std::exception& e) {
63356       {
63357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63358       };
63359     } catch (...) {
63360       {
63361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63362       };
63363     }
63364   }
63365 }
63366
63367
63368 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
63369   int jresult ;
63370   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63371   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
63372
63373   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63374   {
63375     try {
63376       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
63377     } catch (std::out_of_range& e) {
63378       {
63379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63380       };
63381     } catch (std::exception& e) {
63382       {
63383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63384       };
63385     } catch (...) {
63386       {
63387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63388       };
63389     }
63390   }
63391   jresult = (int)result;
63392   return jresult;
63393 }
63394
63395
63396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
63397   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63398   float arg2 ;
63399
63400   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63401   arg2 = (float)jarg2;
63402   {
63403     try {
63404       (arg1)->SetIndicatorFixedHeight(arg2);
63405     } catch (std::out_of_range& e) {
63406       {
63407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63408       };
63409     } catch (std::exception& e) {
63410       {
63411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63412       };
63413     } catch (...) {
63414       {
63415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63416       };
63417     }
63418   }
63419 }
63420
63421
63422 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
63423   float jresult ;
63424   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63425   float result;
63426
63427   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63428   {
63429     try {
63430       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
63431     } catch (std::out_of_range& e) {
63432       {
63433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63434       };
63435     } catch (std::exception& e) {
63436       {
63437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63438       };
63439     } catch (...) {
63440       {
63441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63442       };
63443     }
63444   }
63445   jresult = result;
63446   return jresult;
63447 }
63448
63449
63450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
63451   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63452   float arg2 ;
63453
63454   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63455   arg2 = (float)jarg2;
63456   {
63457     try {
63458       (arg1)->SetIndicatorShowDuration(arg2);
63459     } catch (std::out_of_range& e) {
63460       {
63461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63462       };
63463     } catch (std::exception& e) {
63464       {
63465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63466       };
63467     } catch (...) {
63468       {
63469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63470       };
63471     }
63472   }
63473 }
63474
63475
63476 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
63477   float jresult ;
63478   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63479   float result;
63480
63481   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63482   {
63483     try {
63484       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
63485     } catch (std::out_of_range& e) {
63486       {
63487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63488       };
63489     } catch (std::exception& e) {
63490       {
63491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63492       };
63493     } catch (...) {
63494       {
63495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63496       };
63497     }
63498   }
63499   jresult = result;
63500   return jresult;
63501 }
63502
63503
63504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
63505   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63506   float arg2 ;
63507
63508   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63509   arg2 = (float)jarg2;
63510   {
63511     try {
63512       (arg1)->SetIndicatorHideDuration(arg2);
63513     } catch (std::out_of_range& e) {
63514       {
63515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63516       };
63517     } catch (std::exception& e) {
63518       {
63519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63520       };
63521     } catch (...) {
63522       {
63523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63524       };
63525     }
63526   }
63527 }
63528
63529
63530 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
63531   float jresult ;
63532   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63533   float result;
63534
63535   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63536   {
63537     try {
63538       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
63539     } catch (std::out_of_range& e) {
63540       {
63541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63542       };
63543     } catch (std::exception& e) {
63544       {
63545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63546       };
63547     } catch (...) {
63548       {
63549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63550       };
63551     }
63552   }
63553   jresult = result;
63554   return jresult;
63555 }
63556
63557
63558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
63559   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63560
63561   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63562   {
63563     try {
63564       (arg1)->ShowIndicator();
63565     } catch (std::out_of_range& e) {
63566       {
63567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63568       };
63569     } catch (std::exception& e) {
63570       {
63571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63572       };
63573     } catch (...) {
63574       {
63575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63576       };
63577     }
63578   }
63579 }
63580
63581
63582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
63583   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63584
63585   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63586   {
63587     try {
63588       (arg1)->HideIndicator();
63589     } catch (std::out_of_range& e) {
63590       {
63591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63592       };
63593     } catch (std::exception& e) {
63594       {
63595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63596       };
63597     } catch (...) {
63598       {
63599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63600       };
63601     }
63602   }
63603 }
63604
63605
63606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
63607   void * jresult ;
63608   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63609   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
63610
63611   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63612   {
63613     try {
63614       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
63615     } catch (std::out_of_range& e) {
63616       {
63617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63618       };
63619     } catch (std::exception& e) {
63620       {
63621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63622       };
63623     } catch (...) {
63624       {
63625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63626       };
63627     }
63628   }
63629   jresult = (void *)result;
63630   return jresult;
63631 }
63632
63633
63634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
63635   void * jresult ;
63636   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63637   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
63638
63639   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63640   {
63641     try {
63642       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
63643     } catch (std::out_of_range& e) {
63644       {
63645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63646       };
63647     } catch (std::exception& e) {
63648       {
63649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63650       };
63651     } catch (...) {
63652       {
63653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63654       };
63655     }
63656   }
63657   jresult = (void *)result;
63658   return jresult;
63659 }
63660
63661
63662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
63663   int jresult ;
63664   int result;
63665
63666   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
63667   jresult = (int)result;
63668   return jresult;
63669 }
63670
63671
63672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
63673   int jresult ;
63674   int result;
63675
63676   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
63677   jresult = (int)result;
63678   return jresult;
63679 }
63680
63681
63682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
63683   int jresult ;
63684   int result;
63685
63686   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
63687   jresult = (int)result;
63688   return jresult;
63689 }
63690
63691
63692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
63693   int jresult ;
63694   int result;
63695
63696   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
63697   jresult = (int)result;
63698   return jresult;
63699 }
63700
63701
63702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
63703   int jresult ;
63704   int result;
63705
63706   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
63707   jresult = (int)result;
63708   return jresult;
63709 }
63710
63711
63712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
63713   int jresult ;
63714   int result;
63715
63716   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
63717   jresult = (int)result;
63718   return jresult;
63719 }
63720
63721
63722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
63723   int jresult ;
63724   int result;
63725
63726   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
63727   jresult = (int)result;
63728   return jresult;
63729 }
63730
63731
63732 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
63733   int jresult ;
63734   int result;
63735
63736   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
63737   jresult = (int)result;
63738   return jresult;
63739 }
63740
63741
63742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
63743   int jresult ;
63744   int result;
63745
63746   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
63747   jresult = (int)result;
63748   return jresult;
63749 }
63750
63751
63752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
63753   int jresult ;
63754   int result;
63755
63756   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
63757   jresult = (int)result;
63758   return jresult;
63759 }
63760
63761
63762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
63763   int jresult ;
63764   int result;
63765
63766   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
63767   jresult = (int)result;
63768   return jresult;
63769 }
63770
63771
63772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
63773   int jresult ;
63774   int result;
63775
63776   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
63777   jresult = (int)result;
63778   return jresult;
63779 }
63780
63781
63782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
63783   int jresult ;
63784   int result;
63785
63786   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
63787   jresult = (int)result;
63788   return jresult;
63789 }
63790
63791
63792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
63793   int jresult ;
63794   int result;
63795
63796   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
63797   jresult = (int)result;
63798   return jresult;
63799 }
63800
63801
63802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
63803   void * jresult ;
63804   Dali::Toolkit::Scrollable::Property *result = 0 ;
63805
63806   {
63807     try {
63808       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
63809     } catch (std::out_of_range& e) {
63810       {
63811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63812       };
63813     } catch (std::exception& e) {
63814       {
63815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63816       };
63817     } catch (...) {
63818       {
63819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63820       };
63821     }
63822   }
63823   jresult = (void *)result;
63824   return jresult;
63825 }
63826
63827
63828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
63829   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
63830
63831   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
63832   {
63833     try {
63834       delete arg1;
63835     } catch (std::out_of_range& e) {
63836       {
63837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63838       };
63839     } catch (std::exception& e) {
63840       {
63841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63842       };
63843     } catch (...) {
63844       {
63845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63846       };
63847     }
63848   }
63849 }
63850
63851
63852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
63853   void * jresult ;
63854   Dali::Toolkit::Scrollable *result = 0 ;
63855
63856   {
63857     try {
63858       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
63859     } catch (std::out_of_range& e) {
63860       {
63861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63862       };
63863     } catch (std::exception& e) {
63864       {
63865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63866       };
63867     } catch (...) {
63868       {
63869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63870       };
63871     }
63872   }
63873   jresult = (void *)result;
63874   return jresult;
63875 }
63876
63877
63878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
63879   void * jresult ;
63880   Dali::Toolkit::Scrollable *arg1 = 0 ;
63881   Dali::Toolkit::Scrollable *result = 0 ;
63882
63883   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
63884   if (!arg1) {
63885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
63886     return 0;
63887   }
63888   {
63889     try {
63890       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
63891     } catch (std::out_of_range& e) {
63892       {
63893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63894       };
63895     } catch (std::exception& e) {
63896       {
63897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63898       };
63899     } catch (...) {
63900       {
63901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63902       };
63903     }
63904   }
63905   jresult = (void *)result;
63906   return jresult;
63907 }
63908
63909
63910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
63911   void * jresult ;
63912   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
63913   Dali::Toolkit::Scrollable *arg2 = 0 ;
63914   Dali::Toolkit::Scrollable *result = 0 ;
63915
63916   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
63917   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
63918   if (!arg2) {
63919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
63920     return 0;
63921   }
63922   {
63923     try {
63924       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
63925     } catch (std::out_of_range& e) {
63926       {
63927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63928       };
63929     } catch (std::exception& e) {
63930       {
63931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63932       };
63933     } catch (...) {
63934       {
63935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63936       };
63937     }
63938   }
63939   jresult = (void *)result;
63940   return jresult;
63941 }
63942
63943
63944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
63945   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
63946
63947   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
63948   {
63949     try {
63950       delete arg1;
63951     } catch (std::out_of_range& e) {
63952       {
63953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63954       };
63955     } catch (std::exception& e) {
63956       {
63957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63958       };
63959     } catch (...) {
63960       {
63961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63962       };
63963     }
63964   }
63965 }
63966
63967
63968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
63969   void * jresult ;
63970   Dali::BaseHandle arg1 ;
63971   Dali::BaseHandle *argp1 ;
63972   Dali::Toolkit::Scrollable result;
63973
63974   argp1 = (Dali::BaseHandle *)jarg1;
63975   if (!argp1) {
63976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63977     return 0;
63978   }
63979   arg1 = *argp1;
63980   {
63981     try {
63982       result = Dali::Toolkit::Scrollable::DownCast(arg1);
63983     } catch (std::out_of_range& e) {
63984       {
63985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63986       };
63987     } catch (std::exception& e) {
63988       {
63989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63990       };
63991     } catch (...) {
63992       {
63993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63994       };
63995     }
63996   }
63997   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
63998   return jresult;
63999 }
64000
64001
64002 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
64003   unsigned int jresult ;
64004   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64005   bool result;
64006
64007   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64008   {
64009     try {
64010       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
64011     } catch (std::out_of_range& e) {
64012       {
64013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64014       };
64015     } catch (std::exception& e) {
64016       {
64017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64018       };
64019     } catch (...) {
64020       {
64021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64022       };
64023     }
64024   }
64025   jresult = result;
64026   return jresult;
64027 }
64028
64029
64030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
64031   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64032   bool arg2 ;
64033
64034   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64035   arg2 = jarg2 ? true : false;
64036   {
64037     try {
64038       (arg1)->SetOvershootEnabled(arg2);
64039     } catch (std::out_of_range& e) {
64040       {
64041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64042       };
64043     } catch (std::exception& e) {
64044       {
64045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64046       };
64047     } catch (...) {
64048       {
64049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64050       };
64051     }
64052   }
64053 }
64054
64055
64056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
64057   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64058   Dali::Vector4 *arg2 = 0 ;
64059
64060   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64061   arg2 = (Dali::Vector4 *)jarg2;
64062   if (!arg2) {
64063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
64064     return ;
64065   }
64066   {
64067     try {
64068       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
64069     } catch (std::out_of_range& e) {
64070       {
64071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64072       };
64073     } catch (std::exception& e) {
64074       {
64075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64076       };
64077     } catch (...) {
64078       {
64079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64080       };
64081     }
64082   }
64083 }
64084
64085
64086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
64087   void * jresult ;
64088   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64089   Dali::Vector4 result;
64090
64091   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64092   {
64093     try {
64094       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
64095     } catch (std::out_of_range& e) {
64096       {
64097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64098       };
64099     } catch (std::exception& e) {
64100       {
64101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64102       };
64103     } catch (...) {
64104       {
64105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64106       };
64107     }
64108   }
64109   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
64110   return jresult;
64111 }
64112
64113
64114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
64115   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64116   float arg2 ;
64117
64118   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64119   arg2 = (float)jarg2;
64120   {
64121     try {
64122       (arg1)->SetOvershootAnimationSpeed(arg2);
64123     } catch (std::out_of_range& e) {
64124       {
64125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64126       };
64127     } catch (std::exception& e) {
64128       {
64129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64130       };
64131     } catch (...) {
64132       {
64133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64134       };
64135     }
64136   }
64137 }
64138
64139
64140 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
64141   float jresult ;
64142   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64143   float result;
64144
64145   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64146   {
64147     try {
64148       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
64149     } catch (std::out_of_range& e) {
64150       {
64151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64152       };
64153     } catch (std::exception& e) {
64154       {
64155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64156       };
64157     } catch (...) {
64158       {
64159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64160       };
64161     }
64162   }
64163   jresult = result;
64164   return jresult;
64165 }
64166
64167
64168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
64169   void * jresult ;
64170   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64171   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
64172
64173   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64174   {
64175     try {
64176       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
64177     } catch (std::out_of_range& e) {
64178       {
64179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64180       };
64181     } catch (std::exception& e) {
64182       {
64183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64184       };
64185     } catch (...) {
64186       {
64187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64188       };
64189     }
64190   }
64191   jresult = (void *)result;
64192   return jresult;
64193 }
64194
64195
64196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
64197   void * jresult ;
64198   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64199   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
64200
64201   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64202   {
64203     try {
64204       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
64205     } catch (std::out_of_range& e) {
64206       {
64207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64208       };
64209     } catch (std::exception& e) {
64210       {
64211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64212       };
64213     } catch (...) {
64214       {
64215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64216       };
64217     }
64218   }
64219   jresult = (void *)result;
64220   return jresult;
64221 }
64222
64223
64224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
64225   void * jresult ;
64226   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64227   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
64228
64229   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64230   {
64231     try {
64232       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
64233     } catch (std::out_of_range& e) {
64234       {
64235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64236       };
64237     } catch (std::exception& e) {
64238       {
64239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64240       };
64241     } catch (...) {
64242       {
64243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64244       };
64245     }
64246   }
64247   jresult = (void *)result;
64248   return jresult;
64249 }
64250
64251
64252 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
64253   unsigned int jresult ;
64254   Dali::Toolkit::ControlOrientation::Type arg1 ;
64255   bool result;
64256
64257   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
64258   {
64259     try {
64260       result = (bool)Dali::Toolkit::IsVertical(arg1);
64261     } catch (std::out_of_range& e) {
64262       {
64263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64264       };
64265     } catch (std::exception& e) {
64266       {
64267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64268       };
64269     } catch (...) {
64270       {
64271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64272       };
64273     }
64274   }
64275   jresult = result;
64276   return jresult;
64277 }
64278
64279
64280 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
64281   unsigned int jresult ;
64282   Dali::Toolkit::ControlOrientation::Type arg1 ;
64283   bool result;
64284
64285   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
64286   {
64287     try {
64288       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
64289     } catch (std::out_of_range& e) {
64290       {
64291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64292       };
64293     } catch (std::exception& e) {
64294       {
64295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64296       };
64297     } catch (...) {
64298       {
64299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64300       };
64301     }
64302   }
64303   jresult = result;
64304   return jresult;
64305 }
64306
64307
64308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
64309   void * jresult ;
64310   unsigned int arg1 ;
64311   unsigned int arg2 ;
64312   Dali::Toolkit::ItemRange *result = 0 ;
64313
64314   arg1 = (unsigned int)jarg1;
64315   arg2 = (unsigned int)jarg2;
64316   {
64317     try {
64318       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
64319     } catch (std::out_of_range& e) {
64320       {
64321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64322       };
64323     } catch (std::exception& e) {
64324       {
64325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64326       };
64327     } catch (...) {
64328       {
64329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64330       };
64331     }
64332   }
64333   jresult = (void *)result;
64334   return jresult;
64335 }
64336
64337
64338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
64339   void * jresult ;
64340   Dali::Toolkit::ItemRange *arg1 = 0 ;
64341   Dali::Toolkit::ItemRange *result = 0 ;
64342
64343   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64344   if (!arg1) {
64345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
64346     return 0;
64347   }
64348   {
64349     try {
64350       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
64351     } catch (std::out_of_range& e) {
64352       {
64353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64354       };
64355     } catch (std::exception& e) {
64356       {
64357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64358       };
64359     } catch (...) {
64360       {
64361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64362       };
64363     }
64364   }
64365   jresult = (void *)result;
64366   return jresult;
64367 }
64368
64369
64370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
64371   void * jresult ;
64372   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64373   Dali::Toolkit::ItemRange *arg2 = 0 ;
64374   Dali::Toolkit::ItemRange *result = 0 ;
64375
64376   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64377   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
64378   if (!arg2) {
64379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
64380     return 0;
64381   }
64382   {
64383     try {
64384       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
64385     } catch (std::out_of_range& e) {
64386       {
64387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64388       };
64389     } catch (std::exception& e) {
64390       {
64391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64392       };
64393     } catch (...) {
64394       {
64395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64396       };
64397     }
64398   }
64399   jresult = (void *)result;
64400   return jresult;
64401 }
64402
64403
64404 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
64405   unsigned int jresult ;
64406   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64407   unsigned int arg2 ;
64408   bool result;
64409
64410   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64411   arg2 = (unsigned int)jarg2;
64412   {
64413     try {
64414       result = (bool)(arg1)->Within(arg2);
64415     } catch (std::out_of_range& e) {
64416       {
64417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64418       };
64419     } catch (std::exception& e) {
64420       {
64421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64422       };
64423     } catch (...) {
64424       {
64425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64426       };
64427     }
64428   }
64429   jresult = result;
64430   return jresult;
64431 }
64432
64433
64434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
64435   void * jresult ;
64436   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64437   Dali::Toolkit::ItemRange *arg2 = 0 ;
64438   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
64439
64440   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64441   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
64442   if (!arg2) {
64443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
64444     return 0;
64445   }
64446   {
64447     try {
64448       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
64449     } catch (std::out_of_range& e) {
64450       {
64451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64452       };
64453     } catch (std::exception& e) {
64454       {
64455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64456       };
64457     } catch (...) {
64458       {
64459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64460       };
64461     }
64462   }
64463   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
64464   return jresult;
64465 }
64466
64467
64468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
64469   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64470   unsigned int arg2 ;
64471
64472   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64473   arg2 = (unsigned int)jarg2;
64474   if (arg1) (arg1)->begin = arg2;
64475 }
64476
64477
64478 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
64479   unsigned int jresult ;
64480   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64481   unsigned int result;
64482
64483   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64484   result = (unsigned int) ((arg1)->begin);
64485   jresult = result;
64486   return jresult;
64487 }
64488
64489
64490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
64491   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64492   unsigned int arg2 ;
64493
64494   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64495   arg2 = (unsigned int)jarg2;
64496   if (arg1) (arg1)->end = arg2;
64497 }
64498
64499
64500 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
64501   unsigned int jresult ;
64502   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64503   unsigned int result;
64504
64505   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64506   result = (unsigned int) ((arg1)->end);
64507   jresult = result;
64508   return jresult;
64509 }
64510
64511
64512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
64513   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64514
64515   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64516   {
64517     try {
64518       delete arg1;
64519     } catch (std::out_of_range& e) {
64520       {
64521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64522       };
64523     } catch (std::exception& e) {
64524       {
64525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64526       };
64527     } catch (...) {
64528       {
64529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64530       };
64531     }
64532   }
64533 }
64534
64535
64536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
64537   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64538
64539   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64540   {
64541     try {
64542       delete arg1;
64543     } catch (std::out_of_range& e) {
64544       {
64545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64546       };
64547     } catch (std::exception& e) {
64548       {
64549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64550       };
64551     } catch (...) {
64552       {
64553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64554       };
64555     }
64556   }
64557 }
64558
64559
64560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
64561   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64562   Dali::Toolkit::ControlOrientation::Type arg2 ;
64563
64564   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64565   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
64566   {
64567     try {
64568       (arg1)->SetOrientation(arg2);
64569     } catch (std::out_of_range& e) {
64570       {
64571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64572       };
64573     } catch (std::exception& e) {
64574       {
64575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64576       };
64577     } catch (...) {
64578       {
64579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64580       };
64581     }
64582   }
64583 }
64584
64585
64586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
64587   int jresult ;
64588   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64589   Dali::Toolkit::ControlOrientation::Type result;
64590
64591   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64592   {
64593     try {
64594       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
64595     } catch (std::out_of_range& e) {
64596       {
64597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64598       };
64599     } catch (std::exception& e) {
64600       {
64601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64602       };
64603     } catch (...) {
64604       {
64605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64606       };
64607     }
64608   }
64609   jresult = (int)result;
64610   return jresult;
64611 }
64612
64613
64614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
64615   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64616   Dali::Property::Map *arg2 = 0 ;
64617
64618   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64619   arg2 = (Dali::Property::Map *)jarg2;
64620   if (!arg2) {
64621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
64622     return ;
64623   }
64624   {
64625     try {
64626       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
64627     } catch (std::out_of_range& e) {
64628       {
64629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64630       };
64631     } catch (std::exception& e) {
64632       {
64633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64634       };
64635     } catch (...) {
64636       {
64637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64638       };
64639     }
64640   }
64641 }
64642
64643
64644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
64645   void * jresult ;
64646   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64647   Dali::Property::Map result;
64648
64649   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64650   {
64651     try {
64652       result = (arg1)->GetLayoutProperties();
64653     } catch (std::out_of_range& e) {
64654       {
64655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64656       };
64657     } catch (std::exception& e) {
64658       {
64659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64660       };
64661     } catch (...) {
64662       {
64663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64664       };
64665     }
64666   }
64667   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
64668   return jresult;
64669 }
64670
64671
64672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
64673   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64674   unsigned int arg2 ;
64675   Dali::Vector3 *arg3 = 0 ;
64676   Dali::Vector3 *arg4 = 0 ;
64677
64678   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64679   arg2 = (unsigned int)jarg2;
64680   arg3 = (Dali::Vector3 *)jarg3;
64681   if (!arg3) {
64682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64683     return ;
64684   }
64685   arg4 = (Dali::Vector3 *)jarg4;
64686   if (!arg4) {
64687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
64688     return ;
64689   }
64690   {
64691     try {
64692       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
64693     } catch (std::out_of_range& e) {
64694       {
64695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64696       };
64697     } catch (std::exception& e) {
64698       {
64699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64700       };
64701     } catch (...) {
64702       {
64703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64704       };
64705     }
64706   }
64707 }
64708
64709
64710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
64711   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64712   Dali::Vector3 *arg2 = 0 ;
64713
64714   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64715   arg2 = (Dali::Vector3 *)jarg2;
64716   if (!arg2) {
64717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64718     return ;
64719   }
64720   {
64721     try {
64722       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
64723     } catch (std::out_of_range& e) {
64724       {
64725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64726       };
64727     } catch (std::exception& e) {
64728       {
64729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64730       };
64731     } catch (...) {
64732       {
64733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64734       };
64735     }
64736   }
64737 }
64738
64739
64740 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
64741   float jresult ;
64742   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64743   unsigned int arg2 ;
64744   Dali::Vector3 arg3 ;
64745   Dali::Vector3 *argp3 ;
64746   float result;
64747
64748   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64749   arg2 = (unsigned int)jarg2;
64750   argp3 = (Dali::Vector3 *)jarg3;
64751   if (!argp3) {
64752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
64753     return 0;
64754   }
64755   arg3 = *argp3;
64756   {
64757     try {
64758       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
64759     } catch (std::out_of_range& e) {
64760       {
64761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64762       };
64763     } catch (std::exception& e) {
64764       {
64765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64766       };
64767     } catch (...) {
64768       {
64769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64770       };
64771     }
64772   }
64773   jresult = result;
64774   return jresult;
64775 }
64776
64777
64778 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
64779   float jresult ;
64780   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64781   float arg2 ;
64782   float result;
64783
64784   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64785   arg2 = (float)jarg2;
64786   {
64787     try {
64788       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
64789     } catch (std::out_of_range& e) {
64790       {
64791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64792       };
64793     } catch (std::exception& e) {
64794       {
64795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64796       };
64797     } catch (...) {
64798       {
64799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64800       };
64801     }
64802   }
64803   jresult = result;
64804   return jresult;
64805 }
64806
64807
64808 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
64809   float jresult ;
64810   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64811   unsigned int arg2 ;
64812   float result;
64813
64814   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64815   arg2 = (unsigned int)jarg2;
64816   {
64817     try {
64818       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
64819     } catch (std::out_of_range& e) {
64820       {
64821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64822       };
64823     } catch (std::exception& e) {
64824       {
64825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64826       };
64827     } catch (...) {
64828       {
64829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64830       };
64831     }
64832   }
64833   jresult = result;
64834   return jresult;
64835 }
64836
64837
64838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
64839   void * jresult ;
64840   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64841   float arg2 ;
64842   Dali::Vector3 arg3 ;
64843   Dali::Vector3 *argp3 ;
64844   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
64845
64846   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64847   arg2 = (float)jarg2;
64848   argp3 = (Dali::Vector3 *)jarg3;
64849   if (!argp3) {
64850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
64851     return 0;
64852   }
64853   arg3 = *argp3;
64854   {
64855     try {
64856       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
64857     } catch (std::out_of_range& e) {
64858       {
64859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64860       };
64861     } catch (std::exception& e) {
64862       {
64863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64864       };
64865     } catch (...) {
64866       {
64867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64868       };
64869     }
64870   }
64871   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
64872   return jresult;
64873 }
64874
64875
64876 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
64877   float jresult ;
64878   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64879   int arg2 ;
64880   float arg3 ;
64881   Dali::Vector3 *arg4 = 0 ;
64882   float result;
64883
64884   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64885   arg2 = (int)jarg2;
64886   arg3 = (float)jarg3;
64887   arg4 = (Dali::Vector3 *)jarg4;
64888   if (!arg4) {
64889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64890     return 0;
64891   }
64892   {
64893     try {
64894       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
64895     } catch (std::out_of_range& e) {
64896       {
64897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64898       };
64899     } catch (std::exception& e) {
64900       {
64901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64902       };
64903     } catch (...) {
64904       {
64905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64906       };
64907     }
64908   }
64909   jresult = result;
64910   return jresult;
64911 }
64912
64913
64914 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
64915   unsigned int jresult ;
64916   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64917   Dali::Vector3 arg2 ;
64918   Dali::Vector3 *argp2 ;
64919   unsigned int result;
64920
64921   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64922   argp2 = (Dali::Vector3 *)jarg2;
64923   if (!argp2) {
64924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
64925     return 0;
64926   }
64927   arg2 = *argp2;
64928   {
64929     try {
64930       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
64931     } catch (std::out_of_range& e) {
64932       {
64933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64934       };
64935     } catch (std::exception& e) {
64936       {
64937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64938       };
64939     } catch (...) {
64940       {
64941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64942       };
64943     }
64944   }
64945   jresult = result;
64946   return jresult;
64947 }
64948
64949
64950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
64951   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64952   unsigned int arg2 ;
64953   Dali::Vector3 *arg3 = 0 ;
64954   Dali::Vector3 *arg4 = 0 ;
64955
64956   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64957   arg2 = (unsigned int)jarg2;
64958   arg3 = (Dali::Vector3 *)jarg3;
64959   if (!arg3) {
64960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64961     return ;
64962   }
64963   arg4 = (Dali::Vector3 *)jarg4;
64964   if (!arg4) {
64965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
64966     return ;
64967   }
64968   {
64969     try {
64970       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
64971     } catch (std::out_of_range& e) {
64972       {
64973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64974       };
64975     } catch (std::exception& e) {
64976       {
64977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64978       };
64979     } catch (...) {
64980       {
64981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64982       };
64983     }
64984   }
64985 }
64986
64987
64988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
64989   void * jresult ;
64990   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64991   Dali::Degree result;
64992
64993   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64994   {
64995     try {
64996       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
64997     } catch (std::out_of_range& e) {
64998       {
64999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65000       };
65001     } catch (std::exception& e) {
65002       {
65003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65004       };
65005     } catch (...) {
65006       {
65007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65008       };
65009     }
65010   }
65011   jresult = new Dali::Degree((const Dali::Degree &)result);
65012   return jresult;
65013 }
65014
65015
65016 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
65017   float jresult ;
65018   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65019   float result;
65020
65021   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65022   {
65023     try {
65024       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
65025     } catch (std::out_of_range& e) {
65026       {
65027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65028       };
65029     } catch (std::exception& e) {
65030       {
65031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65032       };
65033     } catch (...) {
65034       {
65035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65036       };
65037     }
65038   }
65039   jresult = result;
65040   return jresult;
65041 }
65042
65043
65044 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
65045   float jresult ;
65046   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65047   float result;
65048
65049   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65050   {
65051     try {
65052       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
65053     } catch (std::out_of_range& e) {
65054       {
65055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65056       };
65057     } catch (std::exception& e) {
65058       {
65059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65060       };
65061     } catch (...) {
65062       {
65063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65064       };
65065     }
65066   }
65067   jresult = result;
65068   return jresult;
65069 }
65070
65071
65072 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
65073   float jresult ;
65074   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65075   float result;
65076
65077   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65078   {
65079     try {
65080       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
65081     } catch (std::out_of_range& e) {
65082       {
65083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65084       };
65085     } catch (std::exception& e) {
65086       {
65087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65088       };
65089     } catch (...) {
65090       {
65091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65092       };
65093     }
65094   }
65095   jresult = result;
65096   return jresult;
65097 }
65098
65099
65100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
65101   int jresult ;
65102   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65103   int arg2 ;
65104   int arg3 ;
65105   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
65106   bool arg5 ;
65107   int result;
65108
65109   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65110   arg2 = (int)jarg2;
65111   arg3 = (int)jarg3;
65112   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
65113   arg5 = jarg5 ? true : false;
65114   {
65115     try {
65116       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
65117     } catch (std::out_of_range& e) {
65118       {
65119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65120       };
65121     } catch (std::exception& e) {
65122       {
65123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65124       };
65125     } catch (...) {
65126       {
65127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65128       };
65129     }
65130   }
65131   jresult = result;
65132   return jresult;
65133 }
65134
65135
65136 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
65137   float jresult ;
65138   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65139   float result;
65140
65141   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65142   {
65143     try {
65144       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
65145     } catch (std::out_of_range& e) {
65146       {
65147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65148       };
65149     } catch (std::exception& e) {
65150       {
65151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65152       };
65153     } catch (...) {
65154       {
65155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65156       };
65157     }
65158   }
65159   jresult = result;
65160   return jresult;
65161 }
65162
65163
65164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
65165   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65166   Dali::Actor *arg2 = 0 ;
65167   int arg3 ;
65168   Dali::Vector3 *arg4 = 0 ;
65169   Dali::Actor *arg5 = 0 ;
65170
65171   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65172   arg2 = (Dali::Actor *)jarg2;
65173   if (!arg2) {
65174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65175     return ;
65176   }
65177   arg3 = (int)jarg3;
65178   arg4 = (Dali::Vector3 *)jarg4;
65179   if (!arg4) {
65180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
65181     return ;
65182   }
65183   arg5 = (Dali::Actor *)jarg5;
65184   if (!arg5) {
65185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65186     return ;
65187   }
65188   {
65189     try {
65190       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
65191     } catch (std::out_of_range& e) {
65192       {
65193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65194       };
65195     } catch (std::exception& e) {
65196       {
65197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65198       };
65199     } catch (...) {
65200       {
65201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65202       };
65203     }
65204   }
65205 }
65206
65207
65208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
65209   void * jresult ;
65210   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65211   int arg2 ;
65212   float arg3 ;
65213   Dali::Vector3 *arg4 = 0 ;
65214   Dali::Vector3 result;
65215
65216   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65217   arg2 = (int)jarg2;
65218   arg3 = (float)jarg3;
65219   arg4 = (Dali::Vector3 *)jarg4;
65220   if (!arg4) {
65221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
65222     return 0;
65223   }
65224   {
65225     try {
65226       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
65227     } catch (std::out_of_range& e) {
65228       {
65229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65230       };
65231     } catch (std::exception& e) {
65232       {
65233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65234       };
65235     } catch (...) {
65236       {
65237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65238       };
65239     }
65240   }
65241   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65242   return jresult;
65243 }
65244
65245
65246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
65247   void * jresult ;
65248   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
65249   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
65250
65251   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
65252   {
65253     try {
65254       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
65255     } catch (std::out_of_range& e) {
65256       {
65257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65258       };
65259     } catch (std::exception& e) {
65260       {
65261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65262       };
65263     } catch (...) {
65264       {
65265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65266       };
65267     }
65268   }
65269   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
65270   return jresult;
65271 }
65272
65273
65274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
65275   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
65276
65277   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65278   {
65279     try {
65280       delete arg1;
65281     } catch (std::out_of_range& e) {
65282       {
65283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65284       };
65285     } catch (std::exception& e) {
65286       {
65287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65288       };
65289     } catch (...) {
65290       {
65291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65292       };
65293     }
65294   }
65295 }
65296
65297
65298 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
65299   unsigned int jresult ;
65300   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
65301   unsigned int result;
65302
65303   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65304   {
65305     try {
65306       result = (unsigned int)(arg1)->GetNumberOfItems();
65307     } catch (std::out_of_range& e) {
65308       {
65309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65310       };
65311     } catch (std::exception& e) {
65312       {
65313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65314       };
65315     } catch (...) {
65316       {
65317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65318       };
65319     }
65320   }
65321   jresult = result;
65322   return jresult;
65323 }
65324
65325
65326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
65327   void * jresult ;
65328   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
65329   unsigned int arg2 ;
65330   Dali::Actor result;
65331
65332   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65333   arg2 = (unsigned int)jarg2;
65334   {
65335     try {
65336       result = (arg1)->NewItem(arg2);
65337     } catch (std::out_of_range& e) {
65338       {
65339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65340       };
65341     } catch (std::exception& e) {
65342       {
65343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65344       };
65345     } catch (...) {
65346       {
65347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65348       };
65349     }
65350   }
65351   jresult = new Dali::Actor((const Dali::Actor &)result);
65352   return jresult;
65353 }
65354
65355
65356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
65357   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
65358   unsigned int arg2 ;
65359   Dali::Actor arg3 ;
65360   Dali::Actor *argp3 ;
65361
65362   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65363   arg2 = (unsigned int)jarg2;
65364   argp3 = (Dali::Actor *)jarg3;
65365   if (!argp3) {
65366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65367     return ;
65368   }
65369   arg3 = *argp3;
65370   {
65371     try {
65372       (arg1)->ItemReleased(arg2,arg3);
65373     } catch (std::out_of_range& e) {
65374       {
65375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65376       };
65377     } catch (std::exception& e) {
65378       {
65379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65380       };
65381     } catch (...) {
65382       {
65383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65384       };
65385     }
65386   }
65387 }
65388
65389
65390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
65391   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
65392   unsigned int arg2 ;
65393   Dali::Actor arg3 ;
65394   Dali::Actor *argp3 ;
65395
65396   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65397   arg2 = (unsigned int)jarg2;
65398   argp3 = (Dali::Actor *)jarg3;
65399   if (!argp3) {
65400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65401     return ;
65402   }
65403   arg3 = *argp3;
65404   {
65405     try {
65406       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
65407     } catch (std::out_of_range& e) {
65408       {
65409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65410       };
65411     } catch (std::exception& e) {
65412       {
65413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65414       };
65415     } catch (...) {
65416       {
65417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65418       };
65419     }
65420   }
65421 }
65422
65423
65424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
65425   void * jresult ;
65426   Dali::Toolkit::ItemFactory *result = 0 ;
65427
65428   {
65429     try {
65430       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
65431     } catch (std::out_of_range& e) {
65432       {
65433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65434       };
65435     } catch (std::exception& e) {
65436       {
65437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65438       };
65439     } catch (...) {
65440       {
65441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65442       };
65443     }
65444   }
65445   jresult = (void *)result;
65446   return jresult;
65447 }
65448
65449
65450 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) {
65451   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
65452   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
65453   if (director) {
65454     director->swig_connect_director(callback0, callback1, callback2);
65455   }
65456 }
65457
65458
65459 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
65460   int jresult ;
65461   int result;
65462
65463   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
65464   jresult = (int)result;
65465   return jresult;
65466 }
65467
65468
65469 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
65470   int jresult ;
65471   int result;
65472
65473   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
65474   jresult = (int)result;
65475   return jresult;
65476 }
65477
65478
65479 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
65480   int jresult ;
65481   int result;
65482
65483   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
65484   jresult = (int)result;
65485   return jresult;
65486 }
65487
65488
65489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
65490   int jresult ;
65491   int result;
65492
65493   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
65494   jresult = (int)result;
65495   return jresult;
65496 }
65497
65498
65499 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
65500   int jresult ;
65501   int result;
65502
65503   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
65504   jresult = (int)result;
65505   return jresult;
65506 }
65507
65508
65509 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
65510   int jresult ;
65511   int result;
65512
65513   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
65514   jresult = (int)result;
65515   return jresult;
65516 }
65517
65518
65519 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
65520   int jresult ;
65521   int result;
65522
65523   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
65524   jresult = (int)result;
65525   return jresult;
65526 }
65527
65528
65529 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
65530   int jresult ;
65531   int result;
65532
65533   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
65534   jresult = (int)result;
65535   return jresult;
65536 }
65537
65538
65539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
65540   int jresult ;
65541   int result;
65542
65543   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
65544   jresult = (int)result;
65545   return jresult;
65546 }
65547
65548
65549 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
65550   int jresult ;
65551   int result;
65552
65553   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
65554   jresult = (int)result;
65555   return jresult;
65556 }
65557
65558
65559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
65560   int jresult ;
65561   int result;
65562
65563   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
65564   jresult = (int)result;
65565   return jresult;
65566 }
65567
65568
65569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
65570   void * jresult ;
65571   Dali::Toolkit::ItemView::Property *result = 0 ;
65572
65573   {
65574     try {
65575       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
65576     } catch (std::out_of_range& e) {
65577       {
65578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65579       };
65580     } catch (std::exception& e) {
65581       {
65582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65583       };
65584     } catch (...) {
65585       {
65586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65587       };
65588     }
65589   }
65590   jresult = (void *)result;
65591   return jresult;
65592 }
65593
65594
65595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
65596   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
65597
65598   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
65599   {
65600     try {
65601       delete arg1;
65602     } catch (std::out_of_range& e) {
65603       {
65604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65605       };
65606     } catch (std::exception& e) {
65607       {
65608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65609       };
65610     } catch (...) {
65611       {
65612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65613       };
65614     }
65615   }
65616 }
65617
65618
65619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
65620   void * jresult ;
65621   Dali::Toolkit::ItemView *result = 0 ;
65622
65623   {
65624     try {
65625       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
65626     } catch (std::out_of_range& e) {
65627       {
65628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65629       };
65630     } catch (std::exception& e) {
65631       {
65632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65633       };
65634     } catch (...) {
65635       {
65636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65637       };
65638     }
65639   }
65640   jresult = (void *)result;
65641   return jresult;
65642 }
65643
65644
65645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
65646   void * jresult ;
65647   Dali::Toolkit::ItemView *arg1 = 0 ;
65648   Dali::Toolkit::ItemView *result = 0 ;
65649
65650   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65651   if (!arg1) {
65652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
65653     return 0;
65654   }
65655   {
65656     try {
65657       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
65658     } catch (std::out_of_range& e) {
65659       {
65660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65661       };
65662     } catch (std::exception& e) {
65663       {
65664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65665       };
65666     } catch (...) {
65667       {
65668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65669       };
65670     }
65671   }
65672   jresult = (void *)result;
65673   return jresult;
65674 }
65675
65676
65677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
65678   void * jresult ;
65679   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65680   Dali::Toolkit::ItemView *arg2 = 0 ;
65681   Dali::Toolkit::ItemView *result = 0 ;
65682
65683   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65684   arg2 = (Dali::Toolkit::ItemView *)jarg2;
65685   if (!arg2) {
65686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
65687     return 0;
65688   }
65689   {
65690     try {
65691       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
65692     } catch (std::out_of_range& e) {
65693       {
65694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65695       };
65696     } catch (std::exception& e) {
65697       {
65698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65699       };
65700     } catch (...) {
65701       {
65702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65703       };
65704     }
65705   }
65706   jresult = (void *)result;
65707   return jresult;
65708 }
65709
65710
65711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
65712   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65713
65714   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65715   {
65716     try {
65717       delete arg1;
65718     } catch (std::out_of_range& e) {
65719       {
65720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65721       };
65722     } catch (std::exception& e) {
65723       {
65724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65725       };
65726     } catch (...) {
65727       {
65728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65729       };
65730     }
65731   }
65732 }
65733
65734
65735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
65736   void * jresult ;
65737   Dali::Toolkit::ItemFactory *arg1 = 0 ;
65738   Dali::Toolkit::ItemView result;
65739
65740   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65741   if (!arg1) {
65742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
65743     return 0;
65744   }
65745   {
65746     try {
65747       result = Dali::Toolkit::ItemView::New(*arg1);
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 = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
65763   return jresult;
65764 }
65765
65766
65767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
65768   void * jresult ;
65769   Dali::BaseHandle arg1 ;
65770   Dali::BaseHandle *argp1 ;
65771   Dali::Toolkit::ItemView result;
65772
65773   argp1 = (Dali::BaseHandle *)jarg1;
65774   if (!argp1) {
65775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65776     return 0;
65777   }
65778   arg1 = *argp1;
65779   {
65780     try {
65781       result = Dali::Toolkit::ItemView::DownCast(arg1);
65782     } catch (std::out_of_range& e) {
65783       {
65784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65785       };
65786     } catch (std::exception& e) {
65787       {
65788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65789       };
65790     } catch (...) {
65791       {
65792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65793       };
65794     }
65795   }
65796   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
65797   return jresult;
65798 }
65799
65800
65801 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
65802   unsigned int jresult ;
65803   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65804   unsigned int result;
65805
65806   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65807   {
65808     try {
65809       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
65810     } catch (std::out_of_range& e) {
65811       {
65812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65813       };
65814     } catch (std::exception& e) {
65815       {
65816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65817       };
65818     } catch (...) {
65819       {
65820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65821       };
65822     }
65823   }
65824   jresult = result;
65825   return jresult;
65826 }
65827
65828
65829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
65830   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65831   Dali::Toolkit::ItemLayout *arg2 = 0 ;
65832
65833   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65834   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
65835   if (!arg2) {
65836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
65837     return ;
65838   }
65839   {
65840     try {
65841       (arg1)->AddLayout(*arg2);
65842     } catch (std::out_of_range& e) {
65843       {
65844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65845       };
65846     } catch (std::exception& e) {
65847       {
65848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65849       };
65850     } catch (...) {
65851       {
65852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65853       };
65854     }
65855   }
65856 }
65857
65858
65859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
65860   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65861   unsigned int arg2 ;
65862
65863   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65864   arg2 = (unsigned int)jarg2;
65865   {
65866     try {
65867       (arg1)->RemoveLayout(arg2);
65868     } catch (std::out_of_range& e) {
65869       {
65870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65871       };
65872     } catch (std::exception& e) {
65873       {
65874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65875       };
65876     } catch (...) {
65877       {
65878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65879       };
65880     }
65881   }
65882 }
65883
65884
65885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
65886   void * jresult ;
65887   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65888   unsigned int arg2 ;
65889   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
65890
65891   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65892   arg2 = (unsigned int)jarg2;
65893   {
65894     try {
65895       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
65896     } catch (std::out_of_range& e) {
65897       {
65898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65899       };
65900     } catch (std::exception& e) {
65901       {
65902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65903       };
65904     } catch (...) {
65905       {
65906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65907       };
65908     }
65909   }
65910   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
65911   return jresult;
65912 }
65913
65914
65915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
65916   void * jresult ;
65917   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65918   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
65919
65920   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65921   {
65922     try {
65923       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
65924     } catch (std::out_of_range& e) {
65925       {
65926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65927       };
65928     } catch (std::exception& e) {
65929       {
65930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65931       };
65932     } catch (...) {
65933       {
65934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65935       };
65936     }
65937   }
65938   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
65939   return jresult;
65940 }
65941
65942
65943 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
65944   float jresult ;
65945   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65946   Dali::Toolkit::ItemId arg2 ;
65947   float result;
65948
65949   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65950   arg2 = (Dali::Toolkit::ItemId)jarg2;
65951   {
65952     try {
65953       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
65954     } catch (std::out_of_range& e) {
65955       {
65956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65957       };
65958     } catch (std::exception& e) {
65959       {
65960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65961       };
65962     } catch (...) {
65963       {
65964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65965       };
65966     }
65967   }
65968   jresult = result;
65969   return jresult;
65970 }
65971
65972
65973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
65974   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65975   unsigned int arg2 ;
65976   Dali::Vector3 arg3 ;
65977   float arg4 ;
65978   Dali::Vector3 *argp3 ;
65979
65980   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65981   arg2 = (unsigned int)jarg2;
65982   argp3 = (Dali::Vector3 *)jarg3;
65983   if (!argp3) {
65984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
65985     return ;
65986   }
65987   arg3 = *argp3;
65988   arg4 = (float)jarg4;
65989   {
65990     try {
65991       (arg1)->ActivateLayout(arg2,arg3,arg4);
65992     } catch (std::out_of_range& e) {
65993       {
65994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65995       };
65996     } catch (std::exception& e) {
65997       {
65998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65999       };
66000     } catch (...) {
66001       {
66002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66003       };
66004     }
66005   }
66006 }
66007
66008
66009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
66010   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66011
66012   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66013   {
66014     try {
66015       (arg1)->DeactivateCurrentLayout();
66016     } catch (std::out_of_range& e) {
66017       {
66018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66019       };
66020     } catch (std::exception& e) {
66021       {
66022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66023       };
66024     } catch (...) {
66025       {
66026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66027       };
66028     }
66029   }
66030 }
66031
66032
66033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
66034   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66035   float arg2 ;
66036
66037   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66038   arg2 = (float)jarg2;
66039   {
66040     try {
66041       (arg1)->SetMinimumSwipeSpeed(arg2);
66042     } catch (std::out_of_range& e) {
66043       {
66044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66045       };
66046     } catch (std::exception& e) {
66047       {
66048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66049       };
66050     } catch (...) {
66051       {
66052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66053       };
66054     }
66055   }
66056 }
66057
66058
66059 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
66060   float jresult ;
66061   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66062   float result;
66063
66064   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66065   {
66066     try {
66067       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
66068     } catch (std::out_of_range& e) {
66069       {
66070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66071       };
66072     } catch (std::exception& e) {
66073       {
66074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66075       };
66076     } catch (...) {
66077       {
66078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66079       };
66080     }
66081   }
66082   jresult = result;
66083   return jresult;
66084 }
66085
66086
66087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
66088   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66089   float arg2 ;
66090
66091   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66092   arg2 = (float)jarg2;
66093   {
66094     try {
66095       (arg1)->SetMinimumSwipeDistance(arg2);
66096     } catch (std::out_of_range& e) {
66097       {
66098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66099       };
66100     } catch (std::exception& e) {
66101       {
66102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66103       };
66104     } catch (...) {
66105       {
66106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66107       };
66108     }
66109   }
66110 }
66111
66112
66113 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
66114   float jresult ;
66115   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66116   float result;
66117
66118   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66119   {
66120     try {
66121       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
66122     } catch (std::out_of_range& e) {
66123       {
66124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66125       };
66126     } catch (std::exception& e) {
66127       {
66128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66129       };
66130     } catch (...) {
66131       {
66132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66133       };
66134     }
66135   }
66136   jresult = result;
66137   return jresult;
66138 }
66139
66140
66141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
66142   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66143   float arg2 ;
66144
66145   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66146   arg2 = (float)jarg2;
66147   {
66148     try {
66149       (arg1)->SetWheelScrollDistanceStep(arg2);
66150     } catch (std::out_of_range& e) {
66151       {
66152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66153       };
66154     } catch (std::exception& e) {
66155       {
66156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66157       };
66158     } catch (...) {
66159       {
66160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66161       };
66162     }
66163   }
66164 }
66165
66166
66167 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
66168   float jresult ;
66169   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66170   float result;
66171
66172   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66173   {
66174     try {
66175       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
66176     } catch (std::out_of_range& e) {
66177       {
66178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66179       };
66180     } catch (std::exception& e) {
66181       {
66182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66183       };
66184     } catch (...) {
66185       {
66186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66187       };
66188     }
66189   }
66190   jresult = result;
66191   return jresult;
66192 }
66193
66194
66195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
66196   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66197   bool arg2 ;
66198
66199   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66200   arg2 = jarg2 ? true : false;
66201   {
66202     try {
66203       (arg1)->SetAnchoring(arg2);
66204     } catch (std::out_of_range& e) {
66205       {
66206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66207       };
66208     } catch (std::exception& e) {
66209       {
66210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66211       };
66212     } catch (...) {
66213       {
66214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66215       };
66216     }
66217   }
66218 }
66219
66220
66221 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
66222   unsigned int jresult ;
66223   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66224   bool result;
66225
66226   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66227   {
66228     try {
66229       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
66230     } catch (std::out_of_range& e) {
66231       {
66232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66233       };
66234     } catch (std::exception& e) {
66235       {
66236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66237       };
66238     } catch (...) {
66239       {
66240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66241       };
66242     }
66243   }
66244   jresult = result;
66245   return jresult;
66246 }
66247
66248
66249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
66250   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66251   float arg2 ;
66252
66253   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66254   arg2 = (float)jarg2;
66255   {
66256     try {
66257       (arg1)->SetAnchoringDuration(arg2);
66258     } catch (std::out_of_range& e) {
66259       {
66260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66261       };
66262     } catch (std::exception& e) {
66263       {
66264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66265       };
66266     } catch (...) {
66267       {
66268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66269       };
66270     }
66271   }
66272 }
66273
66274
66275 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
66276   float jresult ;
66277   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66278   float result;
66279
66280   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66281   {
66282     try {
66283       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
66284     } catch (std::out_of_range& e) {
66285       {
66286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66287       };
66288     } catch (std::exception& e) {
66289       {
66290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66291       };
66292     } catch (...) {
66293       {
66294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66295       };
66296     }
66297   }
66298   jresult = result;
66299   return jresult;
66300 }
66301
66302
66303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
66304   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66305   Dali::Toolkit::ItemId arg2 ;
66306   float arg3 ;
66307
66308   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66309   arg2 = (Dali::Toolkit::ItemId)jarg2;
66310   arg3 = (float)jarg3;
66311   {
66312     try {
66313       (arg1)->ScrollToItem(arg2,arg3);
66314     } catch (std::out_of_range& e) {
66315       {
66316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66317       };
66318     } catch (std::exception& e) {
66319       {
66320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66321       };
66322     } catch (...) {
66323       {
66324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66325       };
66326     }
66327   }
66328 }
66329
66330
66331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
66332   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66333   float arg2 ;
66334
66335   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66336   arg2 = (float)jarg2;
66337   {
66338     try {
66339       (arg1)->SetRefreshInterval(arg2);
66340     } catch (std::out_of_range& e) {
66341       {
66342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66343       };
66344     } catch (std::exception& e) {
66345       {
66346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66347       };
66348     } catch (...) {
66349       {
66350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66351       };
66352     }
66353   }
66354 }
66355
66356
66357 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
66358   float jresult ;
66359   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66360   float result;
66361
66362   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66363   {
66364     try {
66365       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
66366     } catch (std::out_of_range& e) {
66367       {
66368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66369       };
66370     } catch (std::exception& e) {
66371       {
66372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66373       };
66374     } catch (...) {
66375       {
66376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66377       };
66378     }
66379   }
66380   jresult = result;
66381   return jresult;
66382 }
66383
66384
66385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
66386   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66387
66388   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66389   {
66390     try {
66391       (arg1)->Refresh();
66392     } catch (std::out_of_range& e) {
66393       {
66394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66395       };
66396     } catch (std::exception& e) {
66397       {
66398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66399       };
66400     } catch (...) {
66401       {
66402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66403       };
66404     }
66405   }
66406 }
66407
66408
66409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
66410   void * jresult ;
66411   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66412   Dali::Toolkit::ItemId arg2 ;
66413   Dali::Actor result;
66414
66415   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66416   arg2 = (Dali::Toolkit::ItemId)jarg2;
66417   {
66418     try {
66419       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
66420     } catch (std::out_of_range& e) {
66421       {
66422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66423       };
66424     } catch (std::exception& e) {
66425       {
66426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66427       };
66428     } catch (...) {
66429       {
66430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66431       };
66432     }
66433   }
66434   jresult = new Dali::Actor((const Dali::Actor &)result);
66435   return jresult;
66436 }
66437
66438
66439 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
66440   unsigned int jresult ;
66441   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66442   Dali::Actor arg2 ;
66443   Dali::Actor *argp2 ;
66444   Dali::Toolkit::ItemId result;
66445
66446   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66447   argp2 = (Dali::Actor *)jarg2;
66448   if (!argp2) {
66449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66450     return 0;
66451   }
66452   arg2 = *argp2;
66453   {
66454     try {
66455       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
66456     } catch (std::out_of_range& e) {
66457       {
66458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66459       };
66460     } catch (std::exception& e) {
66461       {
66462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66463       };
66464     } catch (...) {
66465       {
66466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66467       };
66468     }
66469   }
66470   jresult = result;
66471   return jresult;
66472 }
66473
66474
66475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
66476   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66477   Dali::Toolkit::Item arg2 ;
66478   float arg3 ;
66479   Dali::Toolkit::Item *argp2 ;
66480
66481   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66482   argp2 = (Dali::Toolkit::Item *)jarg2;
66483   if (!argp2) {
66484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
66485     return ;
66486   }
66487   arg2 = *argp2;
66488   arg3 = (float)jarg3;
66489   {
66490     try {
66491       (arg1)->InsertItem(arg2,arg3);
66492     } catch (std::out_of_range& e) {
66493       {
66494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66495       };
66496     } catch (std::exception& e) {
66497       {
66498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66499       };
66500     } catch (...) {
66501       {
66502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66503       };
66504     }
66505   }
66506 }
66507
66508
66509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
66510   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66511   Dali::Toolkit::ItemContainer *arg2 = 0 ;
66512   float arg3 ;
66513
66514   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66515   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
66516   if (!arg2) {
66517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
66518     return ;
66519   }
66520   arg3 = (float)jarg3;
66521   {
66522     try {
66523       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
66524     } catch (std::out_of_range& e) {
66525       {
66526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66527       };
66528     } catch (std::exception& e) {
66529       {
66530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66531       };
66532     } catch (...) {
66533       {
66534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66535       };
66536     }
66537   }
66538 }
66539
66540
66541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
66542   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66543   Dali::Toolkit::ItemId arg2 ;
66544   float arg3 ;
66545
66546   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66547   arg2 = (Dali::Toolkit::ItemId)jarg2;
66548   arg3 = (float)jarg3;
66549   {
66550     try {
66551       (arg1)->RemoveItem(arg2,arg3);
66552     } catch (std::out_of_range& e) {
66553       {
66554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66555       };
66556     } catch (std::exception& e) {
66557       {
66558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66559       };
66560     } catch (...) {
66561       {
66562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66563       };
66564     }
66565   }
66566 }
66567
66568
66569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
66570   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66571   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
66572   float arg3 ;
66573
66574   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66575   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
66576   if (!arg2) {
66577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
66578     return ;
66579   }
66580   arg3 = (float)jarg3;
66581   {
66582     try {
66583       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
66584     } catch (std::out_of_range& e) {
66585       {
66586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66587       };
66588     } catch (std::exception& e) {
66589       {
66590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66591       };
66592     } catch (...) {
66593       {
66594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66595       };
66596     }
66597   }
66598 }
66599
66600
66601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
66602   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66603   Dali::Toolkit::Item arg2 ;
66604   float arg3 ;
66605   Dali::Toolkit::Item *argp2 ;
66606
66607   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66608   argp2 = (Dali::Toolkit::Item *)jarg2;
66609   if (!argp2) {
66610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
66611     return ;
66612   }
66613   arg2 = *argp2;
66614   arg3 = (float)jarg3;
66615   {
66616     try {
66617       (arg1)->ReplaceItem(arg2,arg3);
66618     } catch (std::out_of_range& e) {
66619       {
66620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66621       };
66622     } catch (std::exception& e) {
66623       {
66624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66625       };
66626     } catch (...) {
66627       {
66628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66629       };
66630     }
66631   }
66632 }
66633
66634
66635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
66636   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66637   Dali::Toolkit::ItemContainer *arg2 = 0 ;
66638   float arg3 ;
66639
66640   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66641   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
66642   if (!arg2) {
66643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
66644     return ;
66645   }
66646   arg3 = (float)jarg3;
66647   {
66648     try {
66649       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
66650     } catch (std::out_of_range& e) {
66651       {
66652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66653       };
66654     } catch (std::exception& e) {
66655       {
66656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66657       };
66658     } catch (...) {
66659       {
66660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66661       };
66662     }
66663   }
66664 }
66665
66666
66667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
66668   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66669   Dali::Vector3 *arg2 = 0 ;
66670
66671   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66672   arg2 = (Dali::Vector3 *)jarg2;
66673   if (!arg2) {
66674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
66675     return ;
66676   }
66677   {
66678     try {
66679       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
66680     } catch (std::out_of_range& e) {
66681       {
66682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66683       };
66684     } catch (std::exception& e) {
66685       {
66686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66687       };
66688     } catch (...) {
66689       {
66690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66691       };
66692     }
66693   }
66694 }
66695
66696
66697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
66698   void * jresult ;
66699   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66700   Dali::Vector3 result;
66701
66702   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66703   {
66704     try {
66705       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
66706     } catch (std::out_of_range& e) {
66707       {
66708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66709       };
66710     } catch (std::exception& e) {
66711       {
66712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66713       };
66714     } catch (...) {
66715       {
66716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66717       };
66718     }
66719   }
66720   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
66721   return jresult;
66722 }
66723
66724
66725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
66726   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66727   Dali::Vector3 *arg2 = 0 ;
66728
66729   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66730   arg2 = (Dali::Vector3 *)jarg2;
66731   if (!arg2) {
66732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
66733     return ;
66734   }
66735   {
66736     try {
66737       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
66738     } catch (std::out_of_range& e) {
66739       {
66740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66741       };
66742     } catch (std::exception& e) {
66743       {
66744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66745       };
66746     } catch (...) {
66747       {
66748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66749       };
66750     }
66751   }
66752 }
66753
66754
66755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
66756   void * jresult ;
66757   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66758   Dali::Vector3 result;
66759
66760   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66761   {
66762     try {
66763       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
66764     } catch (std::out_of_range& e) {
66765       {
66766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66767       };
66768     } catch (std::exception& e) {
66769       {
66770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66771       };
66772     } catch (...) {
66773       {
66774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66775       };
66776     }
66777   }
66778   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
66779   return jresult;
66780 }
66781
66782
66783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
66784   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66785   Dali::Toolkit::ItemRange *arg2 = 0 ;
66786
66787   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66788   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
66789   if (!arg2) {
66790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
66791     return ;
66792   }
66793   {
66794     try {
66795       (arg1)->GetItemsRange(*arg2);
66796     } catch (std::out_of_range& e) {
66797       {
66798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66799       };
66800     } catch (std::exception& e) {
66801       {
66802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66803       };
66804     } catch (...) {
66805       {
66806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66807       };
66808     }
66809   }
66810 }
66811
66812
66813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
66814   void * jresult ;
66815   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66816   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
66817
66818   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66819   {
66820     try {
66821       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
66822     } catch (std::out_of_range& e) {
66823       {
66824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66825       };
66826     } catch (std::exception& e) {
66827       {
66828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66829       };
66830     } catch (...) {
66831       {
66832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66833       };
66834     }
66835   }
66836   jresult = (void *)result;
66837   return jresult;
66838 }
66839
66840
66841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
66842   Dali::Vector3 *arg1 = 0 ;
66843   PropertyInputContainer *arg2 = 0 ;
66844
66845   arg1 = (Dali::Vector3 *)jarg1;
66846   if (!arg1) {
66847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
66848     return ;
66849   }
66850   arg2 = (PropertyInputContainer *)jarg2;
66851   if (!arg2) {
66852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
66853     return ;
66854   }
66855   {
66856     try {
66857       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
66858     } catch (std::out_of_range& e) {
66859       {
66860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66861       };
66862     } catch (std::exception& e) {
66863       {
66864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66865       };
66866     } catch (...) {
66867       {
66868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66869       };
66870     }
66871   }
66872 }
66873
66874
66875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
66876   Dali::Vector3 *arg1 = 0 ;
66877   PropertyInputContainer *arg2 = 0 ;
66878
66879   arg1 = (Dali::Vector3 *)jarg1;
66880   if (!arg1) {
66881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
66882     return ;
66883   }
66884   arg2 = (PropertyInputContainer *)jarg2;
66885   if (!arg2) {
66886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
66887     return ;
66888   }
66889   {
66890     try {
66891       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
66892     } catch (std::out_of_range& e) {
66893       {
66894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66895       };
66896     } catch (std::exception& e) {
66897       {
66898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66899       };
66900     } catch (...) {
66901       {
66902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66903       };
66904     }
66905   }
66906 }
66907
66908
66909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
66910   void * jresult ;
66911   Dali::Toolkit::ScrollViewEffect *result = 0 ;
66912
66913   {
66914     try {
66915       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
66916     } catch (std::out_of_range& e) {
66917       {
66918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66919       };
66920     } catch (std::exception& e) {
66921       {
66922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66923       };
66924     } catch (...) {
66925       {
66926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66927       };
66928     }
66929   }
66930   jresult = (void *)result;
66931   return jresult;
66932 }
66933
66934
66935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
66936   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
66937
66938   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
66939   {
66940     try {
66941       delete arg1;
66942     } catch (std::out_of_range& e) {
66943       {
66944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66945       };
66946     } catch (std::exception& e) {
66947       {
66948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66949       };
66950     } catch (...) {
66951       {
66952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66953       };
66954     }
66955   }
66956 }
66957
66958
66959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
66960   void * jresult ;
66961   Dali::Path arg1 ;
66962   Dali::Vector3 *arg2 = 0 ;
66963   Dali::Property::Index arg3 ;
66964   Dali::Vector3 *arg4 = 0 ;
66965   unsigned int arg5 ;
66966   Dali::Path *argp1 ;
66967   Dali::Toolkit::ScrollViewPagePathEffect result;
66968
66969   argp1 = (Dali::Path *)jarg1;
66970   if (!argp1) {
66971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
66972     return 0;
66973   }
66974   arg1 = *argp1;
66975   arg2 = (Dali::Vector3 *)jarg2;
66976   if (!arg2) {
66977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
66978     return 0;
66979   }
66980   arg3 = (Dali::Property::Index)jarg3;
66981   arg4 = (Dali::Vector3 *)jarg4;
66982   if (!arg4) {
66983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
66984     return 0;
66985   }
66986   arg5 = (unsigned int)jarg5;
66987   {
66988     try {
66989       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
66990     } catch (std::out_of_range& e) {
66991       {
66992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66993       };
66994     } catch (std::exception& e) {
66995       {
66996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66997       };
66998     } catch (...) {
66999       {
67000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67001       };
67002     }
67003   }
67004   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
67005   return jresult;
67006 }
67007
67008
67009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
67010   void * jresult ;
67011   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
67012
67013   {
67014     try {
67015       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
67016     } catch (std::out_of_range& e) {
67017       {
67018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67019       };
67020     } catch (std::exception& e) {
67021       {
67022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67023       };
67024     } catch (...) {
67025       {
67026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67027       };
67028     }
67029   }
67030   jresult = (void *)result;
67031   return jresult;
67032 }
67033
67034
67035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
67036   void * jresult ;
67037   Dali::BaseHandle arg1 ;
67038   Dali::BaseHandle *argp1 ;
67039   Dali::Toolkit::ScrollViewPagePathEffect result;
67040
67041   argp1 = (Dali::BaseHandle *)jarg1;
67042   if (!argp1) {
67043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67044     return 0;
67045   }
67046   arg1 = *argp1;
67047   {
67048     try {
67049       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
67050     } catch (std::out_of_range& e) {
67051       {
67052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67053       };
67054     } catch (std::exception& e) {
67055       {
67056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67057       };
67058     } catch (...) {
67059       {
67060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67061       };
67062     }
67063   }
67064   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
67065   return jresult;
67066 }
67067
67068
67069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
67070   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
67071   Dali::Actor arg2 ;
67072   unsigned int arg3 ;
67073   Dali::Actor *argp2 ;
67074
67075   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
67076   argp2 = (Dali::Actor *)jarg2;
67077   if (!argp2) {
67078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
67079     return ;
67080   }
67081   arg2 = *argp2;
67082   arg3 = (unsigned int)jarg3;
67083   {
67084     try {
67085       (arg1)->ApplyToPage(arg2,arg3);
67086     } catch (std::out_of_range& e) {
67087       {
67088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67089       };
67090     } catch (std::exception& e) {
67091       {
67092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67093       };
67094     } catch (...) {
67095       {
67096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67097       };
67098     }
67099   }
67100 }
67101
67102
67103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
67104   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
67105
67106   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
67107   {
67108     try {
67109       delete arg1;
67110     } catch (std::out_of_range& e) {
67111       {
67112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67113       };
67114     } catch (std::exception& e) {
67115       {
67116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67117       };
67118     } catch (...) {
67119       {
67120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67121       };
67122     }
67123   }
67124 }
67125
67126
67127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
67128   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
67129   Dali::Toolkit::ClampState arg2 ;
67130
67131   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
67132   arg2 = (Dali::Toolkit::ClampState)jarg2;
67133   if (arg1) (arg1)->x = arg2;
67134 }
67135
67136
67137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
67138   int jresult ;
67139   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
67140   Dali::Toolkit::ClampState result;
67141
67142   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
67143   result = (Dali::Toolkit::ClampState) ((arg1)->x);
67144   jresult = (int)result;
67145   return jresult;
67146 }
67147
67148
67149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
67150   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
67151   Dali::Toolkit::ClampState arg2 ;
67152
67153   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
67154   arg2 = (Dali::Toolkit::ClampState)jarg2;
67155   if (arg1) (arg1)->y = arg2;
67156 }
67157
67158
67159 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
67160   int jresult ;
67161   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
67162   Dali::Toolkit::ClampState result;
67163
67164   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
67165   result = (Dali::Toolkit::ClampState) ((arg1)->y);
67166   jresult = (int)result;
67167   return jresult;
67168 }
67169
67170
67171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
67172   void * jresult ;
67173   Dali::Toolkit::ClampState2D *result = 0 ;
67174
67175   {
67176     try {
67177       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
67178     } catch (std::out_of_range& e) {
67179       {
67180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67181       };
67182     } catch (std::exception& e) {
67183       {
67184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67185       };
67186     } catch (...) {
67187       {
67188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67189       };
67190     }
67191   }
67192   jresult = (void *)result;
67193   return jresult;
67194 }
67195
67196
67197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
67198   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
67199
67200   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
67201   {
67202     try {
67203       delete arg1;
67204     } catch (std::out_of_range& e) {
67205       {
67206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67207       };
67208     } catch (std::exception& e) {
67209       {
67210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67211       };
67212     } catch (...) {
67213       {
67214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67215       };
67216     }
67217   }
67218 }
67219
67220
67221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
67222   void * jresult ;
67223   float arg1 ;
67224   float arg2 ;
67225   bool arg3 ;
67226   Dali::Toolkit::RulerDomain *result = 0 ;
67227
67228   arg1 = (float)jarg1;
67229   arg2 = (float)jarg2;
67230   arg3 = jarg3 ? true : false;
67231   {
67232     try {
67233       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
67234     } catch (std::out_of_range& e) {
67235       {
67236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67237       };
67238     } catch (std::exception& e) {
67239       {
67240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67241       };
67242     } catch (...) {
67243       {
67244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67245       };
67246     }
67247   }
67248   jresult = (void *)result;
67249   return jresult;
67250 }
67251
67252
67253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
67254   void * jresult ;
67255   float arg1 ;
67256   float arg2 ;
67257   Dali::Toolkit::RulerDomain *result = 0 ;
67258
67259   arg1 = (float)jarg1;
67260   arg2 = (float)jarg2;
67261   {
67262     try {
67263       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
67264     } catch (std::out_of_range& e) {
67265       {
67266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67267       };
67268     } catch (std::exception& e) {
67269       {
67270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67271       };
67272     } catch (...) {
67273       {
67274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67275       };
67276     }
67277   }
67278   jresult = (void *)result;
67279   return jresult;
67280 }
67281
67282
67283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
67284   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67285   float arg2 ;
67286
67287   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67288   arg2 = (float)jarg2;
67289   if (arg1) (arg1)->min = arg2;
67290 }
67291
67292
67293 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
67294   float jresult ;
67295   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67296   float result;
67297
67298   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67299   result = (float) ((arg1)->min);
67300   jresult = result;
67301   return jresult;
67302 }
67303
67304
67305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
67306   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67307   float arg2 ;
67308
67309   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67310   arg2 = (float)jarg2;
67311   if (arg1) (arg1)->max = arg2;
67312 }
67313
67314
67315 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
67316   float jresult ;
67317   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67318   float result;
67319
67320   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67321   result = (float) ((arg1)->max);
67322   jresult = result;
67323   return jresult;
67324 }
67325
67326
67327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
67328   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67329   bool arg2 ;
67330
67331   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67332   arg2 = jarg2 ? true : false;
67333   if (arg1) (arg1)->enabled = arg2;
67334 }
67335
67336
67337 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
67338   unsigned int jresult ;
67339   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67340   bool result;
67341
67342   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67343   result = (bool) ((arg1)->enabled);
67344   jresult = result;
67345   return jresult;
67346 }
67347
67348
67349 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
67350   float jresult ;
67351   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67352   float arg2 ;
67353   float arg3 ;
67354   float arg4 ;
67355   float result;
67356
67357   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67358   arg2 = (float)jarg2;
67359   arg3 = (float)jarg3;
67360   arg4 = (float)jarg4;
67361   {
67362     try {
67363       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
67364     } catch (std::out_of_range& e) {
67365       {
67366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67367       };
67368     } catch (std::exception& e) {
67369       {
67370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67371       };
67372     } catch (...) {
67373       {
67374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67375       };
67376     }
67377   }
67378   jresult = result;
67379   return jresult;
67380 }
67381
67382
67383 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
67384   float jresult ;
67385   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67386   float arg2 ;
67387   float arg3 ;
67388   float result;
67389
67390   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67391   arg2 = (float)jarg2;
67392   arg3 = (float)jarg3;
67393   {
67394     try {
67395       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
67396     } catch (std::out_of_range& e) {
67397       {
67398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67399       };
67400     } catch (std::exception& e) {
67401       {
67402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67403       };
67404     } catch (...) {
67405       {
67406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67407       };
67408     }
67409   }
67410   jresult = result;
67411   return jresult;
67412 }
67413
67414
67415 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
67416   float jresult ;
67417   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67418   float arg2 ;
67419   float result;
67420
67421   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67422   arg2 = (float)jarg2;
67423   {
67424     try {
67425       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
67426     } catch (std::out_of_range& e) {
67427       {
67428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67429       };
67430     } catch (std::exception& e) {
67431       {
67432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67433       };
67434     } catch (...) {
67435       {
67436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67437       };
67438     }
67439   }
67440   jresult = result;
67441   return jresult;
67442 }
67443
67444
67445 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
67446   float jresult ;
67447   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67448   float arg2 ;
67449   float arg3 ;
67450   float arg4 ;
67451   Dali::Toolkit::ClampState *arg5 = 0 ;
67452   float result;
67453
67454   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67455   arg2 = (float)jarg2;
67456   arg3 = (float)jarg3;
67457   arg4 = (float)jarg4;
67458   arg5 = (Dali::Toolkit::ClampState *)jarg5;
67459   if (!arg5) {
67460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
67461     return 0;
67462   }
67463   {
67464     try {
67465       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
67466     } catch (std::out_of_range& e) {
67467       {
67468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67469       };
67470     } catch (std::exception& e) {
67471       {
67472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67473       };
67474     } catch (...) {
67475       {
67476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67477       };
67478     }
67479   }
67480   jresult = result;
67481   return jresult;
67482 }
67483
67484
67485 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
67486   float jresult ;
67487   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67488   float result;
67489
67490   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67491   {
67492     try {
67493       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
67494     } catch (std::out_of_range& e) {
67495       {
67496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67497       };
67498     } catch (std::exception& e) {
67499       {
67500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67501       };
67502     } catch (...) {
67503       {
67504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67505       };
67506     }
67507   }
67508   jresult = result;
67509   return jresult;
67510 }
67511
67512
67513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
67514   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67515
67516   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67517   {
67518     try {
67519       delete arg1;
67520     } catch (std::out_of_range& e) {
67521       {
67522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67523       };
67524     } catch (std::exception& e) {
67525       {
67526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67527       };
67528     } catch (...) {
67529       {
67530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67531       };
67532     }
67533   }
67534 }
67535
67536
67537 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
67538   float jresult ;
67539   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67540   float arg2 ;
67541   float arg3 ;
67542   float result;
67543
67544   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67545   arg2 = (float)jarg2;
67546   arg3 = (float)jarg3;
67547   {
67548     try {
67549       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
67550     } catch (std::out_of_range& e) {
67551       {
67552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67553       };
67554     } catch (std::exception& e) {
67555       {
67556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67557       };
67558     } catch (...) {
67559       {
67560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67561       };
67562     }
67563   }
67564   jresult = result;
67565   return jresult;
67566 }
67567
67568
67569 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
67570   float jresult ;
67571   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67572   float arg2 ;
67573   float result;
67574
67575   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67576   arg2 = (float)jarg2;
67577   {
67578     try {
67579       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
67580     } catch (std::out_of_range& e) {
67581       {
67582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67583       };
67584     } catch (std::exception& e) {
67585       {
67586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67587       };
67588     } catch (...) {
67589       {
67590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67591       };
67592     }
67593   }
67594   jresult = result;
67595   return jresult;
67596 }
67597
67598
67599 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
67600   float jresult ;
67601   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67602   unsigned int arg2 ;
67603   unsigned int *arg3 = 0 ;
67604   bool arg4 ;
67605   float result;
67606
67607   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67608   arg2 = (unsigned int)jarg2;
67609   arg3 = (unsigned int *)jarg3;
67610   arg4 = jarg4 ? true : false;
67611   {
67612     try {
67613       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
67614     } catch (std::out_of_range& e) {
67615       {
67616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67617       };
67618     } catch (std::exception& e) {
67619       {
67620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67621       };
67622     } catch (...) {
67623       {
67624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67625       };
67626     }
67627   }
67628   jresult = result;
67629   return jresult;
67630 }
67631
67632
67633 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
67634   unsigned int jresult ;
67635   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67636   float arg2 ;
67637   bool arg3 ;
67638   unsigned int result;
67639
67640   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67641   arg2 = (float)jarg2;
67642   arg3 = jarg3 ? true : false;
67643   {
67644     try {
67645       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
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 = result;
67661   return jresult;
67662 }
67663
67664
67665 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
67666   unsigned int jresult ;
67667   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67668   unsigned int result;
67669
67670   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67671   {
67672     try {
67673       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
67674     } catch (std::out_of_range& e) {
67675       {
67676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67677       };
67678     } catch (std::exception& e) {
67679       {
67680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67681       };
67682     } catch (...) {
67683       {
67684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67685       };
67686     }
67687   }
67688   jresult = result;
67689   return jresult;
67690 }
67691
67692
67693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
67694   int jresult ;
67695   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67696   Dali::Toolkit::Ruler::RulerType result;
67697
67698   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67699   {
67700     try {
67701       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
67702     } catch (std::out_of_range& e) {
67703       {
67704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67705       };
67706     } catch (std::exception& e) {
67707       {
67708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67709       };
67710     } catch (...) {
67711       {
67712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67713       };
67714     }
67715   }
67716   jresult = (int)result;
67717   return jresult;
67718 }
67719
67720
67721 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
67722   unsigned int jresult ;
67723   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67724   bool result;
67725
67726   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67727   {
67728     try {
67729       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
67730     } catch (std::out_of_range& e) {
67731       {
67732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67733       };
67734     } catch (std::exception& e) {
67735       {
67736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67737       };
67738     } catch (...) {
67739       {
67740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67741       };
67742     }
67743   }
67744   jresult = result;
67745   return jresult;
67746 }
67747
67748
67749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
67750   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67751
67752   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67753   {
67754     try {
67755       (arg1)->Enable();
67756     } catch (std::out_of_range& e) {
67757       {
67758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67759       };
67760     } catch (std::exception& e) {
67761       {
67762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67763       };
67764     } catch (...) {
67765       {
67766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67767       };
67768     }
67769   }
67770 }
67771
67772
67773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
67774   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67775
67776   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67777   {
67778     try {
67779       (arg1)->Disable();
67780     } catch (std::out_of_range& e) {
67781       {
67782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67783       };
67784     } catch (std::exception& e) {
67785       {
67786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67787       };
67788     } catch (...) {
67789       {
67790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67791       };
67792     }
67793   }
67794 }
67795
67796
67797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
67798   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67799   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
67800   Dali::Toolkit::RulerDomain *argp2 ;
67801
67802   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67803   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
67804   if (!argp2) {
67805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
67806     return ;
67807   }
67808   arg2 = *argp2;
67809   {
67810     try {
67811       (arg1)->SetDomain(arg2);
67812     } catch (std::out_of_range& e) {
67813       {
67814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67815       };
67816     } catch (std::exception& e) {
67817       {
67818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67819       };
67820     } catch (...) {
67821       {
67822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67823       };
67824     }
67825   }
67826 }
67827
67828
67829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
67830   void * jresult ;
67831   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67832   Dali::Toolkit::RulerDomain *result = 0 ;
67833
67834   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67835   {
67836     try {
67837       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
67838     } catch (std::out_of_range& e) {
67839       {
67840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67841       };
67842     } catch (std::exception& e) {
67843       {
67844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67845       };
67846     } catch (...) {
67847       {
67848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67849       };
67850     }
67851   }
67852   jresult = (void *)result;
67853   return jresult;
67854 }
67855
67856
67857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
67858   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67859
67860   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67861   {
67862     try {
67863       (arg1)->DisableDomain();
67864     } catch (std::out_of_range& e) {
67865       {
67866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67867       };
67868     } catch (std::exception& e) {
67869       {
67870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67871       };
67872     } catch (...) {
67873       {
67874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67875       };
67876     }
67877   }
67878 }
67879
67880
67881 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
67882   float jresult ;
67883   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67884   float arg2 ;
67885   float arg3 ;
67886   float arg4 ;
67887   float result;
67888
67889   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67890   arg2 = (float)jarg2;
67891   arg3 = (float)jarg3;
67892   arg4 = (float)jarg4;
67893   {
67894     try {
67895       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
67896     } catch (std::out_of_range& e) {
67897       {
67898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67899       };
67900     } catch (std::exception& e) {
67901       {
67902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67903       };
67904     } catch (...) {
67905       {
67906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67907       };
67908     }
67909   }
67910   jresult = result;
67911   return jresult;
67912 }
67913
67914
67915 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
67916   float jresult ;
67917   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67918   float arg2 ;
67919   float arg3 ;
67920   float result;
67921
67922   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67923   arg2 = (float)jarg2;
67924   arg3 = (float)jarg3;
67925   {
67926     try {
67927       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
67928     } catch (std::out_of_range& e) {
67929       {
67930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67931       };
67932     } catch (std::exception& e) {
67933       {
67934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67935       };
67936     } catch (...) {
67937       {
67938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67939       };
67940     }
67941   }
67942   jresult = result;
67943   return jresult;
67944 }
67945
67946
67947 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
67948   float jresult ;
67949   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67950   float arg2 ;
67951   float result;
67952
67953   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67954   arg2 = (float)jarg2;
67955   {
67956     try {
67957       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
67958     } catch (std::out_of_range& e) {
67959       {
67960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67961       };
67962     } catch (std::exception& e) {
67963       {
67964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67965       };
67966     } catch (...) {
67967       {
67968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67969       };
67970     }
67971   }
67972   jresult = result;
67973   return jresult;
67974 }
67975
67976
67977 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
67978   float jresult ;
67979   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67980   float arg2 ;
67981   float arg3 ;
67982   float arg4 ;
67983   Dali::Toolkit::ClampState *arg5 = 0 ;
67984   float result;
67985
67986   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67987   arg2 = (float)jarg2;
67988   arg3 = (float)jarg3;
67989   arg4 = (float)jarg4;
67990   arg5 = (Dali::Toolkit::ClampState *)jarg5;
67991   if (!arg5) {
67992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
67993     return 0;
67994   }
67995   {
67996     try {
67997       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
67998     } catch (std::out_of_range& e) {
67999       {
68000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68001       };
68002     } catch (std::exception& e) {
68003       {
68004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68005       };
68006     } catch (...) {
68007       {
68008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68009       };
68010     }
68011   }
68012   jresult = result;
68013   return jresult;
68014 }
68015
68016
68017 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
68018   float jresult ;
68019   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68020   float arg2 ;
68021   float arg3 ;
68022   float arg4 ;
68023   float arg5 ;
68024   float result;
68025
68026   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68027   arg2 = (float)jarg2;
68028   arg3 = (float)jarg3;
68029   arg4 = (float)jarg4;
68030   arg5 = (float)jarg5;
68031   {
68032     try {
68033       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
68034     } catch (std::out_of_range& e) {
68035       {
68036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68037       };
68038     } catch (std::exception& e) {
68039       {
68040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68041       };
68042     } catch (...) {
68043       {
68044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68045       };
68046     }
68047   }
68048   jresult = result;
68049   return jresult;
68050 }
68051
68052
68053 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
68054   float jresult ;
68055   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68056   float arg2 ;
68057   float arg3 ;
68058   float arg4 ;
68059   float result;
68060
68061   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68062   arg2 = (float)jarg2;
68063   arg3 = (float)jarg3;
68064   arg4 = (float)jarg4;
68065   {
68066     try {
68067       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
68068     } catch (std::out_of_range& e) {
68069       {
68070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68071       };
68072     } catch (std::exception& e) {
68073       {
68074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68075       };
68076     } catch (...) {
68077       {
68078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68079       };
68080     }
68081   }
68082   jresult = result;
68083   return jresult;
68084 }
68085
68086
68087 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
68088   float jresult ;
68089   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68090   float arg2 ;
68091   float arg3 ;
68092   float result;
68093
68094   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68095   arg2 = (float)jarg2;
68096   arg3 = (float)jarg3;
68097   {
68098     try {
68099       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
68100     } catch (std::out_of_range& e) {
68101       {
68102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68103       };
68104     } catch (std::exception& e) {
68105       {
68106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68107       };
68108     } catch (...) {
68109       {
68110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68111       };
68112     }
68113   }
68114   jresult = result;
68115   return jresult;
68116 }
68117
68118
68119 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
68120   float jresult ;
68121   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68122   float arg2 ;
68123   float result;
68124
68125   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68126   arg2 = (float)jarg2;
68127   {
68128     try {
68129       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
68130     } catch (std::out_of_range& e) {
68131       {
68132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68133       };
68134     } catch (std::exception& e) {
68135       {
68136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68137       };
68138     } catch (...) {
68139       {
68140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68141       };
68142     }
68143   }
68144   jresult = result;
68145   return jresult;
68146 }
68147
68148
68149 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
68150   float jresult ;
68151   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68152   float arg2 ;
68153   float arg3 ;
68154   float arg4 ;
68155   float arg5 ;
68156   Dali::Toolkit::ClampState *arg6 = 0 ;
68157   float result;
68158
68159   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68160   arg2 = (float)jarg2;
68161   arg3 = (float)jarg3;
68162   arg4 = (float)jarg4;
68163   arg5 = (float)jarg5;
68164   arg6 = (Dali::Toolkit::ClampState *)jarg6;
68165   if (!arg6) {
68166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
68167     return 0;
68168   }
68169   {
68170     try {
68171       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
68172     } catch (std::out_of_range& e) {
68173       {
68174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68175       };
68176     } catch (std::exception& e) {
68177       {
68178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68179       };
68180     } catch (...) {
68181       {
68182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68183       };
68184     }
68185   }
68186   jresult = result;
68187   return jresult;
68188 }
68189
68190
68191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
68192   void * jresult ;
68193   Dali::Toolkit::DefaultRuler *result = 0 ;
68194
68195   {
68196     try {
68197       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
68198     } catch (std::out_of_range& e) {
68199       {
68200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68201       };
68202     } catch (std::exception& e) {
68203       {
68204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68205       };
68206     } catch (...) {
68207       {
68208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68209       };
68210     }
68211   }
68212   jresult = (void *)result;
68213   return jresult;
68214 }
68215
68216
68217 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
68218   float jresult ;
68219   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
68220   float arg2 ;
68221   float arg3 ;
68222   float result;
68223
68224   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
68225   arg2 = (float)jarg2;
68226   arg3 = (float)jarg3;
68227   {
68228     try {
68229       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
68230     } catch (std::out_of_range& e) {
68231       {
68232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68233       };
68234     } catch (std::exception& e) {
68235       {
68236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68237       };
68238     } catch (...) {
68239       {
68240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68241       };
68242     }
68243   }
68244   jresult = result;
68245   return jresult;
68246 }
68247
68248
68249 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
68250   float jresult ;
68251   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
68252   unsigned int arg2 ;
68253   unsigned int *arg3 = 0 ;
68254   bool arg4 ;
68255   float result;
68256
68257   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
68258   arg2 = (unsigned int)jarg2;
68259   arg3 = (unsigned int *)jarg3;
68260   arg4 = jarg4 ? true : false;
68261   {
68262     try {
68263       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
68264     } catch (std::out_of_range& e) {
68265       {
68266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68267       };
68268     } catch (std::exception& e) {
68269       {
68270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68271       };
68272     } catch (...) {
68273       {
68274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68275       };
68276     }
68277   }
68278   jresult = result;
68279   return jresult;
68280 }
68281
68282
68283 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
68284   unsigned int jresult ;
68285   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
68286   float arg2 ;
68287   bool arg3 ;
68288   unsigned int result;
68289
68290   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
68291   arg2 = (float)jarg2;
68292   arg3 = jarg3 ? true : false;
68293   {
68294     try {
68295       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
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 = result;
68311   return jresult;
68312 }
68313
68314
68315 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
68316   unsigned int jresult ;
68317   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
68318   unsigned int result;
68319
68320   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
68321   {
68322     try {
68323       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
68324     } catch (std::out_of_range& e) {
68325       {
68326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68327       };
68328     } catch (std::exception& e) {
68329       {
68330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68331       };
68332     } catch (...) {
68333       {
68334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68335       };
68336     }
68337   }
68338   jresult = result;
68339   return jresult;
68340 }
68341
68342
68343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
68344   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
68345
68346   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
68347   {
68348     try {
68349       delete arg1;
68350     } catch (std::out_of_range& e) {
68351       {
68352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68353       };
68354     } catch (std::exception& e) {
68355       {
68356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68357       };
68358     } catch (...) {
68359       {
68360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68361       };
68362     }
68363   }
68364 }
68365
68366
68367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
68368   void * jresult ;
68369   float arg1 ;
68370   Dali::Toolkit::FixedRuler *result = 0 ;
68371
68372   arg1 = (float)jarg1;
68373   {
68374     try {
68375       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
68376     } catch (std::out_of_range& e) {
68377       {
68378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68379       };
68380     } catch (std::exception& e) {
68381       {
68382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68383       };
68384     } catch (...) {
68385       {
68386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68387       };
68388     }
68389   }
68390   jresult = (void *)result;
68391   return jresult;
68392 }
68393
68394
68395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
68396   void * jresult ;
68397   Dali::Toolkit::FixedRuler *result = 0 ;
68398
68399   {
68400     try {
68401       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
68402     } catch (std::out_of_range& e) {
68403       {
68404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68405       };
68406     } catch (std::exception& e) {
68407       {
68408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68409       };
68410     } catch (...) {
68411       {
68412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68413       };
68414     }
68415   }
68416   jresult = (void *)result;
68417   return jresult;
68418 }
68419
68420
68421 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
68422   float jresult ;
68423   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
68424   float arg2 ;
68425   float arg3 ;
68426   float result;
68427
68428   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
68429   arg2 = (float)jarg2;
68430   arg3 = (float)jarg3;
68431   {
68432     try {
68433       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
68434     } catch (std::out_of_range& e) {
68435       {
68436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68437       };
68438     } catch (std::exception& e) {
68439       {
68440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68441       };
68442     } catch (...) {
68443       {
68444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68445       };
68446     }
68447   }
68448   jresult = result;
68449   return jresult;
68450 }
68451
68452
68453 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
68454   float jresult ;
68455   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
68456   unsigned int arg2 ;
68457   unsigned int *arg3 = 0 ;
68458   bool arg4 ;
68459   float result;
68460
68461   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
68462   arg2 = (unsigned int)jarg2;
68463   arg3 = (unsigned int *)jarg3;
68464   arg4 = jarg4 ? true : false;
68465   {
68466     try {
68467       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
68468     } catch (std::out_of_range& e) {
68469       {
68470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68471       };
68472     } catch (std::exception& e) {
68473       {
68474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68475       };
68476     } catch (...) {
68477       {
68478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68479       };
68480     }
68481   }
68482   jresult = result;
68483   return jresult;
68484 }
68485
68486
68487 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
68488   unsigned int jresult ;
68489   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
68490   float arg2 ;
68491   bool arg3 ;
68492   unsigned int result;
68493
68494   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
68495   arg2 = (float)jarg2;
68496   arg3 = jarg3 ? true : false;
68497   {
68498     try {
68499       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
68500     } catch (std::out_of_range& e) {
68501       {
68502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68503       };
68504     } catch (std::exception& e) {
68505       {
68506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68507       };
68508     } catch (...) {
68509       {
68510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68511       };
68512     }
68513   }
68514   jresult = result;
68515   return jresult;
68516 }
68517
68518
68519 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
68520   unsigned int jresult ;
68521   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
68522   unsigned int result;
68523
68524   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
68525   {
68526     try {
68527       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
68528     } catch (std::out_of_range& e) {
68529       {
68530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68531       };
68532     } catch (std::exception& e) {
68533       {
68534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68535       };
68536     } catch (...) {
68537       {
68538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68539       };
68540     }
68541   }
68542   jresult = result;
68543   return jresult;
68544 }
68545
68546
68547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
68548   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
68549
68550   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
68551   {
68552     try {
68553       delete arg1;
68554     } catch (std::out_of_range& e) {
68555       {
68556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68557       };
68558     } catch (std::exception& e) {
68559       {
68560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68561       };
68562     } catch (...) {
68563       {
68564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68565       };
68566     }
68567   }
68568 }
68569
68570
68571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
68572   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68573   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
68574
68575   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68576   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
68577   if (arg1) (arg1)->scale = *arg2;
68578 }
68579
68580
68581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
68582   void * jresult ;
68583   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68584   Dali::Toolkit::ClampState2D *result = 0 ;
68585
68586   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68587   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
68588   jresult = (void *)result;
68589   return jresult;
68590 }
68591
68592
68593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
68594   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68595   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
68596
68597   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68598   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
68599   if (arg1) (arg1)->position = *arg2;
68600 }
68601
68602
68603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
68604   void * jresult ;
68605   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68606   Dali::Toolkit::ClampState2D *result = 0 ;
68607
68608   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68609   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
68610   jresult = (void *)result;
68611   return jresult;
68612 }
68613
68614
68615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
68616   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68617   Dali::Toolkit::ClampState arg2 ;
68618
68619   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68620   arg2 = (Dali::Toolkit::ClampState)jarg2;
68621   if (arg1) (arg1)->rotation = arg2;
68622 }
68623
68624
68625 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
68626   int jresult ;
68627   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68628   Dali::Toolkit::ClampState result;
68629
68630   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68631   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
68632   jresult = (int)result;
68633   return jresult;
68634 }
68635
68636
68637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
68638   void * jresult ;
68639   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
68640
68641   {
68642     try {
68643       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
68644     } catch (std::out_of_range& e) {
68645       {
68646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68647       };
68648     } catch (std::exception& e) {
68649       {
68650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68651       };
68652     } catch (...) {
68653       {
68654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68655       };
68656     }
68657   }
68658   jresult = (void *)result;
68659   return jresult;
68660 }
68661
68662
68663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
68664   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68665
68666   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68667   {
68668     try {
68669       delete arg1;
68670     } catch (std::out_of_range& e) {
68671       {
68672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68673       };
68674     } catch (std::exception& e) {
68675       {
68676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68677       };
68678     } catch (...) {
68679       {
68680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68681       };
68682     }
68683   }
68684 }
68685
68686
68687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
68688   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68689   Dali::Toolkit::SnapType arg2 ;
68690
68691   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68692   arg2 = (Dali::Toolkit::SnapType)jarg2;
68693   if (arg1) (arg1)->type = arg2;
68694 }
68695
68696
68697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
68698   int jresult ;
68699   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68700   Dali::Toolkit::SnapType result;
68701
68702   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68703   result = (Dali::Toolkit::SnapType) ((arg1)->type);
68704   jresult = (int)result;
68705   return jresult;
68706 }
68707
68708
68709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
68710   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68711   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
68712
68713   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68714   arg2 = (Dali::Vector2 *)jarg2;
68715   if (arg1) (arg1)->position = *arg2;
68716 }
68717
68718
68719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
68720   void * jresult ;
68721   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68722   Dali::Vector2 *result = 0 ;
68723
68724   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68725   result = (Dali::Vector2 *)& ((arg1)->position);
68726   jresult = (void *)result;
68727   return jresult;
68728 }
68729
68730
68731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
68732   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68733   float arg2 ;
68734
68735   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68736   arg2 = (float)jarg2;
68737   if (arg1) (arg1)->duration = arg2;
68738 }
68739
68740
68741 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
68742   float jresult ;
68743   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68744   float result;
68745
68746   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68747   result = (float) ((arg1)->duration);
68748   jresult = result;
68749   return jresult;
68750 }
68751
68752
68753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
68754   void * jresult ;
68755   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
68756
68757   {
68758     try {
68759       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
68760     } catch (std::out_of_range& e) {
68761       {
68762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68763       };
68764     } catch (std::exception& e) {
68765       {
68766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68767       };
68768     } catch (...) {
68769       {
68770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68771       };
68772     }
68773   }
68774   jresult = (void *)result;
68775   return jresult;
68776 }
68777
68778
68779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
68780   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68781
68782   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68783   {
68784     try {
68785       delete arg1;
68786     } catch (std::out_of_range& e) {
68787       {
68788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68789       };
68790     } catch (std::exception& e) {
68791       {
68792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68793       };
68794     } catch (...) {
68795       {
68796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68797       };
68798     }
68799   }
68800 }
68801
68802
68803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
68804   int jresult ;
68805   int result;
68806
68807   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
68808   jresult = (int)result;
68809   return jresult;
68810 }
68811
68812
68813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
68814   int jresult ;
68815   int result;
68816
68817   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
68818   jresult = (int)result;
68819   return jresult;
68820 }
68821
68822
68823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
68824   int jresult ;
68825   int result;
68826
68827   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
68828   jresult = (int)result;
68829   return jresult;
68830 }
68831
68832
68833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
68834   int jresult ;
68835   int result;
68836
68837   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
68838   jresult = (int)result;
68839   return jresult;
68840 }
68841
68842
68843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
68844   int jresult ;
68845   int result;
68846
68847   result = (int)Dali::Toolkit::DevelScrollView::Property::SCROLL_MODE;
68848   jresult = (int)result;
68849   return jresult;
68850 }
68851
68852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
68853   int jresult ;
68854   int result;
68855
68856   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
68857   jresult = (int)result;
68858   return jresult;
68859 }
68860
68861
68862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
68863   int jresult ;
68864   int result;
68865
68866   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
68867   jresult = (int)result;
68868   return jresult;
68869 }
68870
68871
68872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
68873   int jresult ;
68874   int result;
68875
68876   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
68877   jresult = (int)result;
68878   return jresult;
68879 }
68880
68881
68882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
68883   int jresult ;
68884   int result;
68885
68886   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
68887   jresult = (int)result;
68888   return jresult;
68889 }
68890
68891
68892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
68893   int jresult ;
68894   int result;
68895
68896   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
68897   jresult = (int)result;
68898   return jresult;
68899 }
68900
68901
68902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
68903   int jresult ;
68904   int result;
68905
68906   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
68907   jresult = (int)result;
68908   return jresult;
68909 }
68910
68911
68912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
68913   int jresult ;
68914   int result;
68915
68916   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
68917   jresult = (int)result;
68918   return jresult;
68919 }
68920
68921
68922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
68923   int jresult ;
68924   int result;
68925
68926   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
68927   jresult = (int)result;
68928   return jresult;
68929 }
68930
68931
68932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
68933   int jresult ;
68934   int result;
68935
68936   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
68937   jresult = (int)result;
68938   return jresult;
68939 }
68940
68941
68942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
68943   int jresult ;
68944   int result;
68945
68946   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
68947   jresult = (int)result;
68948   return jresult;
68949 }
68950
68951
68952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
68953   int jresult ;
68954   int result;
68955
68956   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
68957   jresult = (int)result;
68958   return jresult;
68959 }
68960
68961
68962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
68963   int jresult ;
68964   int result;
68965
68966   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
68967   jresult = (int)result;
68968   return jresult;
68969 }
68970
68971
68972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
68973   int jresult ;
68974   int result;
68975
68976   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
68977   jresult = (int)result;
68978   return jresult;
68979 }
68980
68981
68982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
68983   int jresult ;
68984   int result;
68985
68986   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
68987   jresult = (int)result;
68988   return jresult;
68989 }
68990
68991
68992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
68993   int jresult ;
68994   int result;
68995
68996   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
68997   jresult = (int)result;
68998   return jresult;
68999 }
69000
69001
69002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
69003   int jresult ;
69004   int result;
69005
69006   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
69007   jresult = (int)result;
69008   return jresult;
69009 }
69010
69011
69012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
69013   int jresult ;
69014   int result;
69015
69016   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
69017   jresult = (int)result;
69018   return jresult;
69019 }
69020
69021
69022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
69023   int jresult ;
69024   int result;
69025
69026   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
69027   jresult = (int)result;
69028   return jresult;
69029 }
69030
69031
69032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
69033   int jresult ;
69034   int result;
69035
69036   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
69037   jresult = (int)result;
69038   return jresult;
69039 }
69040
69041
69042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
69043   int jresult ;
69044   int result;
69045
69046   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
69047   jresult = (int)result;
69048   return jresult;
69049 }
69050
69051
69052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
69053   int jresult ;
69054   int result;
69055
69056   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
69057   jresult = (int)result;
69058   return jresult;
69059 }
69060
69061
69062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
69063   void * jresult ;
69064   Dali::Toolkit::ScrollView::Property *result = 0 ;
69065
69066   {
69067     try {
69068       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
69069     } catch (std::out_of_range& e) {
69070       {
69071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69072       };
69073     } catch (std::exception& e) {
69074       {
69075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69076       };
69077     } catch (...) {
69078       {
69079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69080       };
69081     }
69082   }
69083   jresult = (void *)result;
69084   return jresult;
69085 }
69086
69087
69088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
69089   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
69090
69091   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
69092   {
69093     try {
69094       delete arg1;
69095     } catch (std::out_of_range& e) {
69096       {
69097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69098       };
69099     } catch (std::exception& e) {
69100       {
69101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69102       };
69103     } catch (...) {
69104       {
69105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69106       };
69107     }
69108   }
69109 }
69110
69111
69112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
69113   void * jresult ;
69114   Dali::Toolkit::ScrollView *result = 0 ;
69115
69116   {
69117     try {
69118       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
69119     } catch (std::out_of_range& e) {
69120       {
69121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69122       };
69123     } catch (std::exception& e) {
69124       {
69125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69126       };
69127     } catch (...) {
69128       {
69129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69130       };
69131     }
69132   }
69133   jresult = (void *)result;
69134   return jresult;
69135 }
69136
69137
69138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
69139   void * jresult ;
69140   Dali::Toolkit::ScrollView *arg1 = 0 ;
69141   Dali::Toolkit::ScrollView *result = 0 ;
69142
69143   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69144   if (!arg1) {
69145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
69146     return 0;
69147   }
69148   {
69149     try {
69150       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
69151     } catch (std::out_of_range& e) {
69152       {
69153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69154       };
69155     } catch (std::exception& e) {
69156       {
69157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69158       };
69159     } catch (...) {
69160       {
69161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69162       };
69163     }
69164   }
69165   jresult = (void *)result;
69166   return jresult;
69167 }
69168
69169
69170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
69171   void * jresult ;
69172   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69173   Dali::Toolkit::ScrollView *arg2 = 0 ;
69174   Dali::Toolkit::ScrollView *result = 0 ;
69175
69176   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69177   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
69178   if (!arg2) {
69179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
69180     return 0;
69181   }
69182   {
69183     try {
69184       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
69185     } catch (std::out_of_range& e) {
69186       {
69187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69188       };
69189     } catch (std::exception& e) {
69190       {
69191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69192       };
69193     } catch (...) {
69194       {
69195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69196       };
69197     }
69198   }
69199   jresult = (void *)result;
69200   return jresult;
69201 }
69202
69203
69204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
69205   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69206
69207   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69208   {
69209     try {
69210       delete arg1;
69211     } catch (std::out_of_range& e) {
69212       {
69213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69214       };
69215     } catch (std::exception& e) {
69216       {
69217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69218       };
69219     } catch (...) {
69220       {
69221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69222       };
69223     }
69224   }
69225 }
69226
69227
69228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
69229   void * jresult ;
69230   Dali::Toolkit::ScrollView result;
69231
69232   {
69233     try {
69234       result = Dali::Toolkit::ScrollView::New();
69235     } catch (std::out_of_range& e) {
69236       {
69237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69238       };
69239     } catch (std::exception& e) {
69240       {
69241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69242       };
69243     } catch (...) {
69244       {
69245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69246       };
69247     }
69248   }
69249   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
69250   return jresult;
69251 }
69252
69253
69254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
69255   void * jresult ;
69256   Dali::BaseHandle arg1 ;
69257   Dali::BaseHandle *argp1 ;
69258   Dali::Toolkit::ScrollView result;
69259
69260   argp1 = (Dali::BaseHandle *)jarg1;
69261   if (!argp1) {
69262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69263     return 0;
69264   }
69265   arg1 = *argp1;
69266   {
69267     try {
69268       result = Dali::Toolkit::ScrollView::DownCast(arg1);
69269     } catch (std::out_of_range& e) {
69270       {
69271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69272       };
69273     } catch (std::exception& e) {
69274       {
69275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69276       };
69277     } catch (...) {
69278       {
69279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69280       };
69281     }
69282   }
69283   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
69284   return jresult;
69285 }
69286
69287
69288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
69289   void * jresult ;
69290   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69291   Dali::AlphaFunction result;
69292
69293   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69294   {
69295     try {
69296       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
69297     } catch (std::out_of_range& e) {
69298       {
69299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69300       };
69301     } catch (std::exception& e) {
69302       {
69303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69304       };
69305     } catch (...) {
69306       {
69307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69308       };
69309     }
69310   }
69311   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
69312   return jresult;
69313 }
69314
69315
69316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
69317   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69318   Dali::AlphaFunction arg2 ;
69319   Dali::AlphaFunction *argp2 ;
69320
69321   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69322   argp2 = (Dali::AlphaFunction *)jarg2;
69323   if (!argp2) {
69324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
69325     return ;
69326   }
69327   arg2 = *argp2;
69328   {
69329     try {
69330       (arg1)->SetScrollSnapAlphaFunction(arg2);
69331     } catch (std::out_of_range& e) {
69332       {
69333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69334       };
69335     } catch (std::exception& e) {
69336       {
69337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69338       };
69339     } catch (...) {
69340       {
69341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69342       };
69343     }
69344   }
69345 }
69346
69347
69348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
69349   void * jresult ;
69350   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69351   Dali::AlphaFunction result;
69352
69353   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69354   {
69355     try {
69356       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
69357     } catch (std::out_of_range& e) {
69358       {
69359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69360       };
69361     } catch (std::exception& e) {
69362       {
69363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69364       };
69365     } catch (...) {
69366       {
69367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69368       };
69369     }
69370   }
69371   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
69372   return jresult;
69373 }
69374
69375
69376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
69377   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69378   Dali::AlphaFunction arg2 ;
69379   Dali::AlphaFunction *argp2 ;
69380
69381   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69382   argp2 = (Dali::AlphaFunction *)jarg2;
69383   if (!argp2) {
69384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
69385     return ;
69386   }
69387   arg2 = *argp2;
69388   {
69389     try {
69390       (arg1)->SetScrollFlickAlphaFunction(arg2);
69391     } catch (std::out_of_range& e) {
69392       {
69393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69394       };
69395     } catch (std::exception& e) {
69396       {
69397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69398       };
69399     } catch (...) {
69400       {
69401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69402       };
69403     }
69404   }
69405 }
69406
69407
69408 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
69409   float jresult ;
69410   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69411   float result;
69412
69413   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69414   {
69415     try {
69416       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
69417     } catch (std::out_of_range& e) {
69418       {
69419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69420       };
69421     } catch (std::exception& e) {
69422       {
69423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69424       };
69425     } catch (...) {
69426       {
69427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69428       };
69429     }
69430   }
69431   jresult = result;
69432   return jresult;
69433 }
69434
69435
69436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
69437   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69438   float arg2 ;
69439
69440   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69441   arg2 = (float)jarg2;
69442   {
69443     try {
69444       (arg1)->SetScrollSnapDuration(arg2);
69445     } catch (std::out_of_range& e) {
69446       {
69447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69448       };
69449     } catch (std::exception& e) {
69450       {
69451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69452       };
69453     } catch (...) {
69454       {
69455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69456       };
69457     }
69458   }
69459 }
69460
69461
69462 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
69463   float jresult ;
69464   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69465   float result;
69466
69467   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69468   {
69469     try {
69470       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
69471     } catch (std::out_of_range& e) {
69472       {
69473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69474       };
69475     } catch (std::exception& e) {
69476       {
69477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69478       };
69479     } catch (...) {
69480       {
69481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69482       };
69483     }
69484   }
69485   jresult = result;
69486   return jresult;
69487 }
69488
69489
69490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
69491   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69492   float arg2 ;
69493
69494   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69495   arg2 = (float)jarg2;
69496   {
69497     try {
69498       (arg1)->SetScrollFlickDuration(arg2);
69499     } catch (std::out_of_range& e) {
69500       {
69501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69502       };
69503     } catch (std::exception& e) {
69504       {
69505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69506       };
69507     } catch (...) {
69508       {
69509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69510       };
69511     }
69512   }
69513 }
69514
69515
69516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
69517   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69518   Dali::Toolkit::RulerPtr arg2 ;
69519   Dali::Toolkit::RulerPtr *argp2 ;
69520
69521   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69522   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
69523   if (!argp2) {
69524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
69525     return ;
69526   }
69527   arg2 = *argp2;
69528   {
69529     try {
69530       (arg1)->SetRulerX(arg2);
69531     } catch (std::out_of_range& e) {
69532       {
69533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69534       };
69535     } catch (std::exception& e) {
69536       {
69537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69538       };
69539     } catch (...) {
69540       {
69541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69542       };
69543     }
69544   }
69545 }
69546
69547
69548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
69549   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69550   Dali::Toolkit::RulerPtr arg2 ;
69551   Dali::Toolkit::RulerPtr *argp2 ;
69552
69553   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69554   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
69555   if (!argp2) {
69556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
69557     return ;
69558   }
69559   arg2 = *argp2;
69560   {
69561     try {
69562       (arg1)->SetRulerY(arg2);
69563     } catch (std::out_of_range& e) {
69564       {
69565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69566       };
69567     } catch (std::exception& e) {
69568       {
69569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69570       };
69571     } catch (...) {
69572       {
69573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69574       };
69575     }
69576   }
69577 }
69578
69579
69580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
69581   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69582   bool arg2 ;
69583
69584   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69585   arg2 = jarg2 ? true : false;
69586   {
69587     try {
69588       (arg1)->SetScrollSensitive(arg2);
69589     } catch (std::out_of_range& e) {
69590       {
69591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69592       };
69593     } catch (std::exception& e) {
69594       {
69595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69596       };
69597     } catch (...) {
69598       {
69599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69600       };
69601     }
69602   }
69603 }
69604
69605
69606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
69607   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69608   float arg2 ;
69609   float arg3 ;
69610
69611   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69612   arg2 = (float)jarg2;
69613   arg3 = (float)jarg3;
69614   {
69615     try {
69616       (arg1)->SetMaxOvershoot(arg2,arg3);
69617     } catch (std::out_of_range& e) {
69618       {
69619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69620       };
69621     } catch (std::exception& e) {
69622       {
69623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69624       };
69625     } catch (...) {
69626       {
69627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69628       };
69629     }
69630   }
69631 }
69632
69633
69634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
69635   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69636   Dali::AlphaFunction arg2 ;
69637   Dali::AlphaFunction *argp2 ;
69638
69639   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69640   argp2 = (Dali::AlphaFunction *)jarg2;
69641   if (!argp2) {
69642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
69643     return ;
69644   }
69645   arg2 = *argp2;
69646   {
69647     try {
69648       (arg1)->SetSnapOvershootAlphaFunction(arg2);
69649     } catch (std::out_of_range& e) {
69650       {
69651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69652       };
69653     } catch (std::exception& e) {
69654       {
69655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69656       };
69657     } catch (...) {
69658       {
69659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69660       };
69661     }
69662   }
69663 }
69664
69665
69666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
69667   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69668   float arg2 ;
69669
69670   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69671   arg2 = (float)jarg2;
69672   {
69673     try {
69674       (arg1)->SetSnapOvershootDuration(arg2);
69675     } catch (std::out_of_range& e) {
69676       {
69677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69678       };
69679     } catch (std::exception& e) {
69680       {
69681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69682       };
69683     } catch (...) {
69684       {
69685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69686       };
69687     }
69688   }
69689 }
69690
69691
69692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
69693   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69694   bool arg2 ;
69695
69696   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69697   arg2 = jarg2 ? true : false;
69698   {
69699     try {
69700       (arg1)->SetActorAutoSnap(arg2);
69701     } catch (std::out_of_range& e) {
69702       {
69703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69704       };
69705     } catch (std::exception& e) {
69706       {
69707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69708       };
69709     } catch (...) {
69710       {
69711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69712       };
69713     }
69714   }
69715 }
69716
69717
69718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
69719   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69720   bool arg2 ;
69721
69722   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69723   arg2 = jarg2 ? true : false;
69724   {
69725     try {
69726       (arg1)->SetWrapMode(arg2);
69727     } catch (std::out_of_range& e) {
69728       {
69729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69730       };
69731     } catch (std::exception& e) {
69732       {
69733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69734       };
69735     } catch (...) {
69736       {
69737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69738       };
69739     }
69740   }
69741 }
69742
69743
69744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
69745   int jresult ;
69746   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69747   int result;
69748
69749   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69750   {
69751     try {
69752       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
69753     } catch (std::out_of_range& e) {
69754       {
69755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69756       };
69757     } catch (std::exception& e) {
69758       {
69759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69760       };
69761     } catch (...) {
69762       {
69763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69764       };
69765     }
69766   }
69767   jresult = result;
69768   return jresult;
69769 }
69770
69771
69772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
69773   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69774   int arg2 ;
69775
69776   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69777   arg2 = (int)jarg2;
69778   {
69779     try {
69780       (arg1)->SetScrollUpdateDistance(arg2);
69781     } catch (std::out_of_range& e) {
69782       {
69783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69784       };
69785     } catch (std::exception& e) {
69786       {
69787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69788       };
69789     } catch (...) {
69790       {
69791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69792       };
69793     }
69794   }
69795 }
69796
69797
69798 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
69799   unsigned int jresult ;
69800   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69801   bool result;
69802
69803   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69804   {
69805     try {
69806       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
69807     } catch (std::out_of_range& e) {
69808       {
69809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69810       };
69811     } catch (std::exception& e) {
69812       {
69813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69814       };
69815     } catch (...) {
69816       {
69817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69818       };
69819     }
69820   }
69821   jresult = result;
69822   return jresult;
69823 }
69824
69825
69826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
69827   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69828   bool arg2 ;
69829
69830   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69831   arg2 = jarg2 ? true : false;
69832   {
69833     try {
69834       (arg1)->SetAxisAutoLock(arg2);
69835     } catch (std::out_of_range& e) {
69836       {
69837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69838       };
69839     } catch (std::exception& e) {
69840       {
69841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69842       };
69843     } catch (...) {
69844       {
69845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69846       };
69847     }
69848   }
69849 }
69850
69851
69852 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
69853   float jresult ;
69854   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69855   float result;
69856
69857   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69858   {
69859     try {
69860       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
69861     } catch (std::out_of_range& e) {
69862       {
69863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69864       };
69865     } catch (std::exception& e) {
69866       {
69867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69868       };
69869     } catch (...) {
69870       {
69871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69872       };
69873     }
69874   }
69875   jresult = result;
69876   return jresult;
69877 }
69878
69879
69880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
69881   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69882   float arg2 ;
69883
69884   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69885   arg2 = (float)jarg2;
69886   {
69887     try {
69888       (arg1)->SetAxisAutoLockGradient(arg2);
69889     } catch (std::out_of_range& e) {
69890       {
69891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69892       };
69893     } catch (std::exception& e) {
69894       {
69895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69896       };
69897     } catch (...) {
69898       {
69899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69900       };
69901     }
69902   }
69903 }
69904
69905
69906 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
69907   float jresult ;
69908   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69909   float result;
69910
69911   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69912   {
69913     try {
69914       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
69915     } catch (std::out_of_range& e) {
69916       {
69917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69918       };
69919     } catch (std::exception& e) {
69920       {
69921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69922       };
69923     } catch (...) {
69924       {
69925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69926       };
69927     }
69928   }
69929   jresult = result;
69930   return jresult;
69931 }
69932
69933
69934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
69935   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69936   float arg2 ;
69937
69938   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69939   arg2 = (float)jarg2;
69940   {
69941     try {
69942       (arg1)->SetFrictionCoefficient(arg2);
69943     } catch (std::out_of_range& e) {
69944       {
69945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69946       };
69947     } catch (std::exception& e) {
69948       {
69949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69950       };
69951     } catch (...) {
69952       {
69953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69954       };
69955     }
69956   }
69957 }
69958
69959
69960 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
69961   float jresult ;
69962   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69963   float result;
69964
69965   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69966   {
69967     try {
69968       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
69969     } catch (std::out_of_range& e) {
69970       {
69971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69972       };
69973     } catch (std::exception& e) {
69974       {
69975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69976       };
69977     } catch (...) {
69978       {
69979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69980       };
69981     }
69982   }
69983   jresult = result;
69984   return jresult;
69985 }
69986
69987
69988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
69989   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69990   float arg2 ;
69991
69992   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69993   arg2 = (float)jarg2;
69994   {
69995     try {
69996       (arg1)->SetFlickSpeedCoefficient(arg2);
69997     } catch (std::out_of_range& e) {
69998       {
69999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70000       };
70001     } catch (std::exception& e) {
70002       {
70003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70004       };
70005     } catch (...) {
70006       {
70007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70008       };
70009     }
70010   }
70011 }
70012
70013
70014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
70015   void * jresult ;
70016   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70017   Dali::Vector2 result;
70018
70019   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70020   {
70021     try {
70022       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
70023     } catch (std::out_of_range& e) {
70024       {
70025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70026       };
70027     } catch (std::exception& e) {
70028       {
70029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70030       };
70031     } catch (...) {
70032       {
70033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70034       };
70035     }
70036   }
70037   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
70038   return jresult;
70039 }
70040
70041
70042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
70043   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70044   Dali::Vector2 *arg2 = 0 ;
70045
70046   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70047   arg2 = (Dali::Vector2 *)jarg2;
70048   if (!arg2) {
70049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70050     return ;
70051   }
70052   {
70053     try {
70054       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
70055     } catch (std::out_of_range& e) {
70056       {
70057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70058       };
70059     } catch (std::exception& e) {
70060       {
70061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70062       };
70063     } catch (...) {
70064       {
70065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70066       };
70067     }
70068   }
70069 }
70070
70071
70072 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
70073   float jresult ;
70074   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70075   float result;
70076
70077   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70078   {
70079     try {
70080       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
70081     } catch (std::out_of_range& e) {
70082       {
70083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70084       };
70085     } catch (std::exception& e) {
70086       {
70087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70088       };
70089     } catch (...) {
70090       {
70091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70092       };
70093     }
70094   }
70095   jresult = result;
70096   return jresult;
70097 }
70098
70099
70100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
70101   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70102   float arg2 ;
70103
70104   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70105   arg2 = (float)jarg2;
70106   {
70107     try {
70108       (arg1)->SetMinimumSpeedForFlick(arg2);
70109     } catch (std::out_of_range& e) {
70110       {
70111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70112       };
70113     } catch (std::exception& e) {
70114       {
70115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70116       };
70117     } catch (...) {
70118       {
70119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70120       };
70121     }
70122   }
70123 }
70124
70125
70126 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
70127   float jresult ;
70128   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70129   float result;
70130
70131   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70132   {
70133     try {
70134       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
70135     } catch (std::out_of_range& e) {
70136       {
70137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70138       };
70139     } catch (std::exception& e) {
70140       {
70141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70142       };
70143     } catch (...) {
70144       {
70145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70146       };
70147     }
70148   }
70149   jresult = result;
70150   return jresult;
70151 }
70152
70153
70154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
70155   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70156   float arg2 ;
70157
70158   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70159   arg2 = (float)jarg2;
70160   {
70161     try {
70162       (arg1)->SetMaxFlickSpeed(arg2);
70163     } catch (std::out_of_range& e) {
70164       {
70165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70166       };
70167     } catch (std::exception& e) {
70168       {
70169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70170       };
70171     } catch (...) {
70172       {
70173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70174       };
70175     }
70176   }
70177 }
70178
70179
70180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
70181   void * jresult ;
70182   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70183   Dali::Vector2 result;
70184
70185   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70186   {
70187     try {
70188       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
70189     } catch (std::out_of_range& e) {
70190       {
70191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70192       };
70193     } catch (std::exception& e) {
70194       {
70195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70196       };
70197     } catch (...) {
70198       {
70199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70200       };
70201     }
70202   }
70203   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
70204   return jresult;
70205 }
70206
70207
70208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
70209   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70210   Dali::Vector2 arg2 ;
70211   Dali::Vector2 *argp2 ;
70212
70213   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70214   argp2 = (Dali::Vector2 *)jarg2;
70215   if (!argp2) {
70216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
70217     return ;
70218   }
70219   arg2 = *argp2;
70220   {
70221     try {
70222       (arg1)->SetWheelScrollDistanceStep(arg2);
70223     } catch (std::out_of_range& e) {
70224       {
70225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70226       };
70227     } catch (std::exception& e) {
70228       {
70229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70230       };
70231     } catch (...) {
70232       {
70233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70234       };
70235     }
70236   }
70237 }
70238
70239
70240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
70241   void * jresult ;
70242   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70243   Dali::Vector2 result;
70244
70245   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70246   {
70247     try {
70248       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
70249     } catch (std::out_of_range& e) {
70250       {
70251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70252       };
70253     } catch (std::exception& e) {
70254       {
70255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70256       };
70257     } catch (...) {
70258       {
70259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70260       };
70261     }
70262   }
70263   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
70264   return jresult;
70265 }
70266
70267
70268 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
70269   unsigned int jresult ;
70270   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70271   unsigned int result;
70272
70273   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70274   {
70275     try {
70276       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
70277     } catch (std::out_of_range& e) {
70278       {
70279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70280       };
70281     } catch (std::exception& e) {
70282       {
70283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70284       };
70285     } catch (...) {
70286       {
70287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70288       };
70289     }
70290   }
70291   jresult = result;
70292   return jresult;
70293 }
70294
70295
70296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
70297   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70298   Dali::Vector2 *arg2 = 0 ;
70299
70300   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70301   arg2 = (Dali::Vector2 *)jarg2;
70302   if (!arg2) {
70303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70304     return ;
70305   }
70306   {
70307     try {
70308       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
70309     } catch (std::out_of_range& e) {
70310       {
70311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70312       };
70313     } catch (std::exception& e) {
70314       {
70315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70316       };
70317     } catch (...) {
70318       {
70319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70320       };
70321     }
70322   }
70323 }
70324
70325
70326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
70327   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70328   Dali::Vector2 *arg2 = 0 ;
70329   float arg3 ;
70330
70331   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70332   arg2 = (Dali::Vector2 *)jarg2;
70333   if (!arg2) {
70334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70335     return ;
70336   }
70337   arg3 = (float)jarg3;
70338   {
70339     try {
70340       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
70341     } catch (std::out_of_range& e) {
70342       {
70343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70344       };
70345     } catch (std::exception& e) {
70346       {
70347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70348       };
70349     } catch (...) {
70350       {
70351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70352       };
70353     }
70354   }
70355 }
70356
70357
70358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
70359   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70360   Dali::Vector2 *arg2 = 0 ;
70361   float arg3 ;
70362   Dali::AlphaFunction arg4 ;
70363   Dali::AlphaFunction *argp4 ;
70364
70365   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70366   arg2 = (Dali::Vector2 *)jarg2;
70367   if (!arg2) {
70368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70369     return ;
70370   }
70371   arg3 = (float)jarg3;
70372   argp4 = (Dali::AlphaFunction *)jarg4;
70373   if (!argp4) {
70374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
70375     return ;
70376   }
70377   arg4 = *argp4;
70378   {
70379     try {
70380       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
70381     } catch (std::out_of_range& e) {
70382       {
70383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70384       };
70385     } catch (std::exception& e) {
70386       {
70387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70388       };
70389     } catch (...) {
70390       {
70391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70392       };
70393     }
70394   }
70395 }
70396
70397
70398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
70399   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70400   Dali::Vector2 *arg2 = 0 ;
70401   float arg3 ;
70402   Dali::Toolkit::DirectionBias arg4 ;
70403   Dali::Toolkit::DirectionBias arg5 ;
70404
70405   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70406   arg2 = (Dali::Vector2 *)jarg2;
70407   if (!arg2) {
70408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70409     return ;
70410   }
70411   arg3 = (float)jarg3;
70412   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
70413   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
70414   {
70415     try {
70416       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
70417     } catch (std::out_of_range& e) {
70418       {
70419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70420       };
70421     } catch (std::exception& e) {
70422       {
70423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70424       };
70425     } catch (...) {
70426       {
70427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70428       };
70429     }
70430   }
70431 }
70432
70433
70434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
70435   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70436   Dali::Vector2 *arg2 = 0 ;
70437   float arg3 ;
70438   Dali::AlphaFunction arg4 ;
70439   Dali::Toolkit::DirectionBias arg5 ;
70440   Dali::Toolkit::DirectionBias arg6 ;
70441   Dali::AlphaFunction *argp4 ;
70442
70443   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70444   arg2 = (Dali::Vector2 *)jarg2;
70445   if (!arg2) {
70446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70447     return ;
70448   }
70449   arg3 = (float)jarg3;
70450   argp4 = (Dali::AlphaFunction *)jarg4;
70451   if (!argp4) {
70452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
70453     return ;
70454   }
70455   arg4 = *argp4;
70456   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
70457   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
70458   {
70459     try {
70460       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
70461     } catch (std::out_of_range& e) {
70462       {
70463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70464       };
70465     } catch (std::exception& e) {
70466       {
70467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70468       };
70469     } catch (...) {
70470       {
70471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70472       };
70473     }
70474   }
70475 }
70476
70477
70478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
70479   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70480   unsigned int arg2 ;
70481
70482   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70483   arg2 = (unsigned int)jarg2;
70484   {
70485     try {
70486       (arg1)->ScrollTo(arg2);
70487     } catch (std::out_of_range& e) {
70488       {
70489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70490       };
70491     } catch (std::exception& e) {
70492       {
70493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70494       };
70495     } catch (...) {
70496       {
70497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70498       };
70499     }
70500   }
70501 }
70502
70503
70504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
70505   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70506   unsigned int arg2 ;
70507   float arg3 ;
70508
70509   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70510   arg2 = (unsigned int)jarg2;
70511   arg3 = (float)jarg3;
70512   {
70513     try {
70514       (arg1)->ScrollTo(arg2,arg3);
70515     } catch (std::out_of_range& e) {
70516       {
70517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70518       };
70519     } catch (std::exception& e) {
70520       {
70521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70522       };
70523     } catch (...) {
70524       {
70525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70526       };
70527     }
70528   }
70529 }
70530
70531
70532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
70533   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70534   unsigned int arg2 ;
70535   float arg3 ;
70536   Dali::Toolkit::DirectionBias arg4 ;
70537
70538   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70539   arg2 = (unsigned int)jarg2;
70540   arg3 = (float)jarg3;
70541   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
70542   {
70543     try {
70544       (arg1)->ScrollTo(arg2,arg3,arg4);
70545     } catch (std::out_of_range& e) {
70546       {
70547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70548       };
70549     } catch (std::exception& e) {
70550       {
70551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70552       };
70553     } catch (...) {
70554       {
70555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70556       };
70557     }
70558   }
70559 }
70560
70561
70562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
70563   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70564   Dali::Actor *arg2 = 0 ;
70565
70566   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70567   arg2 = (Dali::Actor *)jarg2;
70568   if (!arg2) {
70569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
70570     return ;
70571   }
70572   {
70573     try {
70574       (arg1)->ScrollTo(*arg2);
70575     } catch (std::out_of_range& e) {
70576       {
70577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70578       };
70579     } catch (std::exception& e) {
70580       {
70581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70582       };
70583     } catch (...) {
70584       {
70585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70586       };
70587     }
70588   }
70589 }
70590
70591
70592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
70593   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70594   Dali::Actor *arg2 = 0 ;
70595   float arg3 ;
70596
70597   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70598   arg2 = (Dali::Actor *)jarg2;
70599   if (!arg2) {
70600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
70601     return ;
70602   }
70603   arg3 = (float)jarg3;
70604   {
70605     try {
70606       (arg1)->ScrollTo(*arg2,arg3);
70607     } catch (std::out_of_range& e) {
70608       {
70609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70610       };
70611     } catch (std::exception& e) {
70612       {
70613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70614       };
70615     } catch (...) {
70616       {
70617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70618       };
70619     }
70620   }
70621 }
70622
70623
70624 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
70625   unsigned int jresult ;
70626   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70627   bool result;
70628
70629   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70630   {
70631     try {
70632       result = (bool)(arg1)->ScrollToSnapPoint();
70633     } catch (std::out_of_range& e) {
70634       {
70635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70636       };
70637     } catch (std::exception& e) {
70638       {
70639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70640       };
70641     } catch (...) {
70642       {
70643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70644       };
70645     }
70646   }
70647   jresult = result;
70648   return jresult;
70649 }
70650
70651
70652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
70653   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70654   Dali::Constraint arg2 ;
70655   Dali::Constraint *argp2 ;
70656
70657   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70658   argp2 = (Dali::Constraint *)jarg2;
70659   if (!argp2) {
70660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
70661     return ;
70662   }
70663   arg2 = *argp2;
70664   {
70665     try {
70666       (arg1)->ApplyConstraintToChildren(arg2);
70667     } catch (std::out_of_range& e) {
70668       {
70669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70670       };
70671     } catch (std::exception& e) {
70672       {
70673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70674       };
70675     } catch (...) {
70676       {
70677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70678       };
70679     }
70680   }
70681 }
70682
70683
70684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
70685   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70686
70687   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70688   {
70689     try {
70690       (arg1)->RemoveConstraintsFromChildren();
70691     } catch (std::out_of_range& e) {
70692       {
70693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70694       };
70695     } catch (std::exception& e) {
70696       {
70697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70698       };
70699     } catch (...) {
70700       {
70701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70702       };
70703     }
70704   }
70705 }
70706
70707
70708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
70709   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70710   Dali::Toolkit::ScrollViewEffect arg2 ;
70711   Dali::Toolkit::ScrollViewEffect *argp2 ;
70712
70713   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70714   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
70715   if (!argp2) {
70716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
70717     return ;
70718   }
70719   arg2 = *argp2;
70720   {
70721     try {
70722       (arg1)->ApplyEffect(arg2);
70723     } catch (std::out_of_range& e) {
70724       {
70725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70726       };
70727     } catch (std::exception& e) {
70728       {
70729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70730       };
70731     } catch (...) {
70732       {
70733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70734       };
70735     }
70736   }
70737 }
70738
70739
70740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
70741   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70742   Dali::Toolkit::ScrollViewEffect arg2 ;
70743   Dali::Toolkit::ScrollViewEffect *argp2 ;
70744
70745   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70746   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
70747   if (!argp2) {
70748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
70749     return ;
70750   }
70751   arg2 = *argp2;
70752   {
70753     try {
70754       (arg1)->RemoveEffect(arg2);
70755     } catch (std::out_of_range& e) {
70756       {
70757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70758       };
70759     } catch (std::exception& e) {
70760       {
70761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70762       };
70763     } catch (...) {
70764       {
70765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70766       };
70767     }
70768   }
70769 }
70770
70771
70772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
70773   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70774
70775   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70776   {
70777     try {
70778       (arg1)->RemoveAllEffects();
70779     } catch (std::out_of_range& e) {
70780       {
70781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70782       };
70783     } catch (std::exception& e) {
70784       {
70785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70786       };
70787     } catch (...) {
70788       {
70789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70790       };
70791     }
70792   }
70793 }
70794
70795
70796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
70797   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70798   Dali::Actor arg2 ;
70799   Dali::Actor *argp2 ;
70800
70801   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70802   argp2 = (Dali::Actor *)jarg2;
70803   if (!argp2) {
70804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70805     return ;
70806   }
70807   arg2 = *argp2;
70808   {
70809     try {
70810       (arg1)->BindActor(arg2);
70811     } catch (std::out_of_range& e) {
70812       {
70813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70814       };
70815     } catch (std::exception& e) {
70816       {
70817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70818       };
70819     } catch (...) {
70820       {
70821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70822       };
70823     }
70824   }
70825 }
70826
70827
70828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
70829   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70830   Dali::Actor arg2 ;
70831   Dali::Actor *argp2 ;
70832
70833   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70834   argp2 = (Dali::Actor *)jarg2;
70835   if (!argp2) {
70836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70837     return ;
70838   }
70839   arg2 = *argp2;
70840   {
70841     try {
70842       (arg1)->UnbindActor(arg2);
70843     } catch (std::out_of_range& e) {
70844       {
70845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70846       };
70847     } catch (std::exception& e) {
70848       {
70849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70850       };
70851     } catch (...) {
70852       {
70853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70854       };
70855     }
70856   }
70857 }
70858
70859
70860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
70861   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70862   Dali::Radian arg2 ;
70863   Dali::Radian arg3 ;
70864   Dali::Radian *argp2 ;
70865   Dali::Radian *argp3 ;
70866
70867   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70868   argp2 = (Dali::Radian *)jarg2;
70869   if (!argp2) {
70870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
70871     return ;
70872   }
70873   arg2 = *argp2;
70874   argp3 = (Dali::Radian *)jarg3;
70875   if (!argp3) {
70876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
70877     return ;
70878   }
70879   arg3 = *argp3;
70880   {
70881     try {
70882       (arg1)->SetScrollingDirection(arg2,arg3);
70883     } catch (std::out_of_range& e) {
70884       {
70885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70886       };
70887     } catch (std::exception& e) {
70888       {
70889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70890       };
70891     } catch (...) {
70892       {
70893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70894       };
70895     }
70896   }
70897 }
70898
70899
70900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
70901   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70902   Dali::Radian arg2 ;
70903   Dali::Radian *argp2 ;
70904
70905   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70906   argp2 = (Dali::Radian *)jarg2;
70907   if (!argp2) {
70908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
70909     return ;
70910   }
70911   arg2 = *argp2;
70912   {
70913     try {
70914       (arg1)->SetScrollingDirection(arg2);
70915     } catch (std::out_of_range& e) {
70916       {
70917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70918       };
70919     } catch (std::exception& e) {
70920       {
70921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70922       };
70923     } catch (...) {
70924       {
70925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70926       };
70927     }
70928   }
70929 }
70930
70931
70932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
70933   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70934   Dali::Radian arg2 ;
70935   Dali::Radian *argp2 ;
70936
70937   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70938   argp2 = (Dali::Radian *)jarg2;
70939   if (!argp2) {
70940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
70941     return ;
70942   }
70943   arg2 = *argp2;
70944   {
70945     try {
70946       (arg1)->RemoveScrollingDirection(arg2);
70947     } catch (std::out_of_range& e) {
70948       {
70949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70950       };
70951     } catch (std::exception& e) {
70952       {
70953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70954       };
70955     } catch (...) {
70956       {
70957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70958       };
70959     }
70960   }
70961 }
70962
70963
70964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
70965   void * jresult ;
70966   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70967   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
70968
70969   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70970   {
70971     try {
70972       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
70973     } catch (std::out_of_range& e) {
70974       {
70975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70976       };
70977     } catch (std::exception& e) {
70978       {
70979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70980       };
70981     } catch (...) {
70982       {
70983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70984       };
70985     }
70986   }
70987   jresult = (void *)result;
70988   return jresult;
70989 }
70990
70991
70992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
70993   int jresult ;
70994   int result;
70995
70996   result = (int)Dali::Toolkit::TableView::Property::ROWS;
70997   jresult = (int)result;
70998   return jresult;
70999 }
71000
71001
71002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
71003   int jresult ;
71004   int result;
71005
71006   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
71007   jresult = (int)result;
71008   return jresult;
71009 }
71010
71011
71012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
71013   int jresult ;
71014   int result;
71015
71016   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
71017   jresult = (int)result;
71018   return jresult;
71019 }
71020
71021
71022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
71023   int jresult ;
71024   int result;
71025
71026   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
71027   jresult = (int)result;
71028   return jresult;
71029 }
71030
71031
71032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
71033   int jresult ;
71034   int result;
71035
71036   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
71037   jresult = (int)result;
71038   return jresult;
71039 }
71040
71041
71042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
71043   void * jresult ;
71044   Dali::Toolkit::TableView::Property *result = 0 ;
71045
71046   {
71047     try {
71048       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
71049     } catch (std::out_of_range& e) {
71050       {
71051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71052       };
71053     } catch (std::exception& e) {
71054       {
71055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71056       };
71057     } catch (...) {
71058       {
71059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71060       };
71061     }
71062   }
71063   jresult = (void *)result;
71064   return jresult;
71065 }
71066
71067
71068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
71069   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
71070
71071   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
71072   {
71073     try {
71074       delete arg1;
71075     } catch (std::out_of_range& e) {
71076       {
71077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71078       };
71079     } catch (std::exception& e) {
71080       {
71081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71082       };
71083     } catch (...) {
71084       {
71085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71086       };
71087     }
71088   }
71089 }
71090
71091
71092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
71093   int jresult ;
71094   int result;
71095
71096   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
71097   jresult = (int)result;
71098   return jresult;
71099 }
71100
71101
71102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
71103   int jresult ;
71104   int result;
71105
71106   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
71107   jresult = (int)result;
71108   return jresult;
71109 }
71110
71111
71112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
71113   int jresult ;
71114   int result;
71115
71116   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
71117   jresult = (int)result;
71118   return jresult;
71119 }
71120
71121
71122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
71123   int jresult ;
71124   int result;
71125
71126   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
71127   jresult = (int)result;
71128   return jresult;
71129 }
71130
71131
71132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
71133   int jresult ;
71134   int result;
71135
71136   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
71137   jresult = (int)result;
71138   return jresult;
71139 }
71140
71141
71142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
71143   void * jresult ;
71144   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
71145
71146   {
71147     try {
71148       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
71149     } catch (std::out_of_range& e) {
71150       {
71151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71152       };
71153     } catch (std::exception& e) {
71154       {
71155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71156       };
71157     } catch (...) {
71158       {
71159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71160       };
71161     }
71162   }
71163   jresult = (void *)result;
71164   return jresult;
71165 }
71166
71167
71168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
71169   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
71170
71171   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
71172   {
71173     try {
71174       delete arg1;
71175     } catch (std::out_of_range& e) {
71176       {
71177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71178       };
71179     } catch (std::exception& e) {
71180       {
71181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71182       };
71183     } catch (...) {
71184       {
71185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71186       };
71187     }
71188   }
71189 }
71190
71191
71192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
71193   void * jresult ;
71194   unsigned int arg1 ;
71195   unsigned int arg2 ;
71196   unsigned int arg3 ;
71197   unsigned int arg4 ;
71198   Dali::Toolkit::TableView::CellPosition *result = 0 ;
71199
71200   arg1 = (unsigned int)jarg1;
71201   arg2 = (unsigned int)jarg2;
71202   arg3 = (unsigned int)jarg3;
71203   arg4 = (unsigned int)jarg4;
71204   {
71205     try {
71206       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
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 = (void *)result;
71222   return jresult;
71223 }
71224
71225
71226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
71227   void * jresult ;
71228   unsigned int arg1 ;
71229   unsigned int arg2 ;
71230   unsigned int arg3 ;
71231   Dali::Toolkit::TableView::CellPosition *result = 0 ;
71232
71233   arg1 = (unsigned int)jarg1;
71234   arg2 = (unsigned int)jarg2;
71235   arg3 = (unsigned int)jarg3;
71236   {
71237     try {
71238       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
71239     } catch (std::out_of_range& e) {
71240       {
71241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71242       };
71243     } catch (std::exception& e) {
71244       {
71245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71246       };
71247     } catch (...) {
71248       {
71249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71250       };
71251     }
71252   }
71253   jresult = (void *)result;
71254   return jresult;
71255 }
71256
71257
71258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
71259   void * jresult ;
71260   unsigned int arg1 ;
71261   unsigned int arg2 ;
71262   Dali::Toolkit::TableView::CellPosition *result = 0 ;
71263
71264   arg1 = (unsigned int)jarg1;
71265   arg2 = (unsigned int)jarg2;
71266   {
71267     try {
71268       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
71269     } catch (std::out_of_range& e) {
71270       {
71271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71272       };
71273     } catch (std::exception& e) {
71274       {
71275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71276       };
71277     } catch (...) {
71278       {
71279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71280       };
71281     }
71282   }
71283   jresult = (void *)result;
71284   return jresult;
71285 }
71286
71287
71288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
71289   void * jresult ;
71290   unsigned int arg1 ;
71291   Dali::Toolkit::TableView::CellPosition *result = 0 ;
71292
71293   arg1 = (unsigned int)jarg1;
71294   {
71295     try {
71296       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
71297     } catch (std::out_of_range& e) {
71298       {
71299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71300       };
71301     } catch (std::exception& e) {
71302       {
71303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71304       };
71305     } catch (...) {
71306       {
71307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71308       };
71309     }
71310   }
71311   jresult = (void *)result;
71312   return jresult;
71313 }
71314
71315
71316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
71317   void * jresult ;
71318   Dali::Toolkit::TableView::CellPosition *result = 0 ;
71319
71320   {
71321     try {
71322       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
71323     } catch (std::out_of_range& e) {
71324       {
71325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71326       };
71327     } catch (std::exception& e) {
71328       {
71329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71330       };
71331     } catch (...) {
71332       {
71333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71334       };
71335     }
71336   }
71337   jresult = (void *)result;
71338   return jresult;
71339 }
71340
71341
71342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
71343   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71344   unsigned int arg2 ;
71345
71346   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71347   arg2 = (unsigned int)jarg2;
71348   if (arg1) (arg1)->rowIndex = arg2;
71349 }
71350
71351
71352 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
71353   unsigned int jresult ;
71354   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71355   unsigned int result;
71356
71357   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71358   result = (unsigned int) ((arg1)->rowIndex);
71359   jresult = result;
71360   return jresult;
71361 }
71362
71363
71364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
71365   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71366   unsigned int arg2 ;
71367
71368   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71369   arg2 = (unsigned int)jarg2;
71370   if (arg1) (arg1)->columnIndex = arg2;
71371 }
71372
71373
71374 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
71375   unsigned int jresult ;
71376   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71377   unsigned int result;
71378
71379   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71380   result = (unsigned int) ((arg1)->columnIndex);
71381   jresult = result;
71382   return jresult;
71383 }
71384
71385
71386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
71387   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71388   unsigned int arg2 ;
71389
71390   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71391   arg2 = (unsigned int)jarg2;
71392   if (arg1) (arg1)->rowSpan = arg2;
71393 }
71394
71395
71396 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
71397   unsigned int jresult ;
71398   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71399   unsigned int result;
71400
71401   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71402   result = (unsigned int) ((arg1)->rowSpan);
71403   jresult = result;
71404   return jresult;
71405 }
71406
71407
71408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
71409   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71410   unsigned int arg2 ;
71411
71412   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71413   arg2 = (unsigned int)jarg2;
71414   if (arg1) (arg1)->columnSpan = arg2;
71415 }
71416
71417
71418 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
71419   unsigned int jresult ;
71420   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71421   unsigned int result;
71422
71423   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71424   result = (unsigned int) ((arg1)->columnSpan);
71425   jresult = result;
71426   return jresult;
71427 }
71428
71429
71430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
71431   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71432
71433   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71434   {
71435     try {
71436       delete arg1;
71437     } catch (std::out_of_range& e) {
71438       {
71439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71440       };
71441     } catch (std::exception& e) {
71442       {
71443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71444       };
71445     } catch (...) {
71446       {
71447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71448       };
71449     }
71450   }
71451 }
71452
71453
71454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
71455   void * jresult ;
71456   Dali::Toolkit::TableView *result = 0 ;
71457
71458   {
71459     try {
71460       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
71461     } catch (std::out_of_range& e) {
71462       {
71463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71464       };
71465     } catch (std::exception& e) {
71466       {
71467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71468       };
71469     } catch (...) {
71470       {
71471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71472       };
71473     }
71474   }
71475   jresult = (void *)result;
71476   return jresult;
71477 }
71478
71479
71480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
71481   void * jresult ;
71482   Dali::Toolkit::TableView *arg1 = 0 ;
71483   Dali::Toolkit::TableView *result = 0 ;
71484
71485   arg1 = (Dali::Toolkit::TableView *)jarg1;
71486   if (!arg1) {
71487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
71488     return 0;
71489   }
71490   {
71491     try {
71492       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
71493     } catch (std::out_of_range& e) {
71494       {
71495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71496       };
71497     } catch (std::exception& e) {
71498       {
71499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71500       };
71501     } catch (...) {
71502       {
71503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71504       };
71505     }
71506   }
71507   jresult = (void *)result;
71508   return jresult;
71509 }
71510
71511
71512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
71513   void * jresult ;
71514   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71515   Dali::Toolkit::TableView *arg2 = 0 ;
71516   Dali::Toolkit::TableView *result = 0 ;
71517
71518   arg1 = (Dali::Toolkit::TableView *)jarg1;
71519   arg2 = (Dali::Toolkit::TableView *)jarg2;
71520   if (!arg2) {
71521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
71522     return 0;
71523   }
71524   {
71525     try {
71526       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
71527     } catch (std::out_of_range& e) {
71528       {
71529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71530       };
71531     } catch (std::exception& e) {
71532       {
71533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71534       };
71535     } catch (...) {
71536       {
71537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71538       };
71539     }
71540   }
71541   jresult = (void *)result;
71542   return jresult;
71543 }
71544
71545
71546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
71547   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71548
71549   arg1 = (Dali::Toolkit::TableView *)jarg1;
71550   {
71551     try {
71552       delete arg1;
71553     } catch (std::out_of_range& e) {
71554       {
71555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71556       };
71557     } catch (std::exception& e) {
71558       {
71559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71560       };
71561     } catch (...) {
71562       {
71563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71564       };
71565     }
71566   }
71567 }
71568
71569
71570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
71571   void * jresult ;
71572   unsigned int arg1 ;
71573   unsigned int arg2 ;
71574   Dali::Toolkit::TableView result;
71575
71576   arg1 = (unsigned int)jarg1;
71577   arg2 = (unsigned int)jarg2;
71578   {
71579     try {
71580       result = Dali::Toolkit::TableView::New(arg1,arg2);
71581     } catch (std::out_of_range& e) {
71582       {
71583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71584       };
71585     } catch (std::exception& e) {
71586       {
71587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71588       };
71589     } catch (...) {
71590       {
71591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71592       };
71593     }
71594   }
71595   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
71596   return jresult;
71597 }
71598
71599
71600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
71601   void * jresult ;
71602   Dali::BaseHandle arg1 ;
71603   Dali::BaseHandle *argp1 ;
71604   Dali::Toolkit::TableView result;
71605
71606   argp1 = (Dali::BaseHandle *)jarg1;
71607   if (!argp1) {
71608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71609     return 0;
71610   }
71611   arg1 = *argp1;
71612   {
71613     try {
71614       result = Dali::Toolkit::TableView::DownCast(arg1);
71615     } catch (std::out_of_range& e) {
71616       {
71617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71618       };
71619     } catch (std::exception& e) {
71620       {
71621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71622       };
71623     } catch (...) {
71624       {
71625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71626       };
71627     }
71628   }
71629   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
71630   return jresult;
71631 }
71632
71633
71634 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
71635   unsigned int jresult ;
71636   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71637   Dali::Actor arg2 ;
71638   Dali::Toolkit::TableView::CellPosition arg3 ;
71639   Dali::Actor *argp2 ;
71640   Dali::Toolkit::TableView::CellPosition *argp3 ;
71641   bool result;
71642
71643   arg1 = (Dali::Toolkit::TableView *)jarg1;
71644   argp2 = (Dali::Actor *)jarg2;
71645   if (!argp2) {
71646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71647     return 0;
71648   }
71649   arg2 = *argp2;
71650   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
71651   if (!argp3) {
71652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
71653     return 0;
71654   }
71655   arg3 = *argp3;
71656   {
71657     try {
71658       result = (bool)(arg1)->AddChild(arg2,arg3);
71659     } catch (std::out_of_range& e) {
71660       {
71661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71662       };
71663     } catch (std::exception& e) {
71664       {
71665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71666       };
71667     } catch (...) {
71668       {
71669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71670       };
71671     }
71672   }
71673   jresult = result;
71674   return jresult;
71675 }
71676
71677
71678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
71679   void * jresult ;
71680   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71681   Dali::Toolkit::TableView::CellPosition arg2 ;
71682   Dali::Toolkit::TableView::CellPosition *argp2 ;
71683   Dali::Actor result;
71684
71685   arg1 = (Dali::Toolkit::TableView *)jarg1;
71686   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
71687   if (!argp2) {
71688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
71689     return 0;
71690   }
71691   arg2 = *argp2;
71692   {
71693     try {
71694       result = (arg1)->GetChildAt(arg2);
71695     } catch (std::out_of_range& e) {
71696       {
71697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71698       };
71699     } catch (std::exception& e) {
71700       {
71701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71702       };
71703     } catch (...) {
71704       {
71705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71706       };
71707     }
71708   }
71709   jresult = new Dali::Actor((const Dali::Actor &)result);
71710   return jresult;
71711 }
71712
71713
71714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
71715   void * jresult ;
71716   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71717   Dali::Toolkit::TableView::CellPosition arg2 ;
71718   Dali::Toolkit::TableView::CellPosition *argp2 ;
71719   Dali::Actor result;
71720
71721   arg1 = (Dali::Toolkit::TableView *)jarg1;
71722   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
71723   if (!argp2) {
71724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
71725     return 0;
71726   }
71727   arg2 = *argp2;
71728   {
71729     try {
71730       result = (arg1)->RemoveChildAt(arg2);
71731     } catch (std::out_of_range& e) {
71732       {
71733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71734       };
71735     } catch (std::exception& e) {
71736       {
71737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71738       };
71739     } catch (...) {
71740       {
71741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71742       };
71743     }
71744   }
71745   jresult = new Dali::Actor((const Dali::Actor &)result);
71746   return jresult;
71747 }
71748
71749
71750 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
71751   unsigned int jresult ;
71752   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71753   Dali::Actor arg2 ;
71754   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
71755   Dali::Actor *argp2 ;
71756   bool result;
71757
71758   arg1 = (Dali::Toolkit::TableView *)jarg1;
71759   argp2 = (Dali::Actor *)jarg2;
71760   if (!argp2) {
71761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71762     return 0;
71763   }
71764   arg2 = *argp2;
71765   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
71766   if (!arg3) {
71767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
71768     return 0;
71769   }
71770   {
71771     try {
71772       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
71773     } catch (std::out_of_range& e) {
71774       {
71775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71776       };
71777     } catch (std::exception& e) {
71778       {
71779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71780       };
71781     } catch (...) {
71782       {
71783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71784       };
71785     }
71786   }
71787   jresult = result;
71788   return jresult;
71789 }
71790
71791
71792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
71793   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71794   unsigned int arg2 ;
71795
71796   arg1 = (Dali::Toolkit::TableView *)jarg1;
71797   arg2 = (unsigned int)jarg2;
71798   {
71799     try {
71800       (arg1)->InsertRow(arg2);
71801     } catch (std::out_of_range& e) {
71802       {
71803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71804       };
71805     } catch (std::exception& e) {
71806       {
71807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71808       };
71809     } catch (...) {
71810       {
71811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71812       };
71813     }
71814   }
71815 }
71816
71817
71818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
71819   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71820   unsigned int arg2 ;
71821
71822   arg1 = (Dali::Toolkit::TableView *)jarg1;
71823   arg2 = (unsigned int)jarg2;
71824   {
71825     try {
71826       (arg1)->DeleteRow(arg2);
71827     } catch (std::out_of_range& e) {
71828       {
71829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71830       };
71831     } catch (std::exception& e) {
71832       {
71833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71834       };
71835     } catch (...) {
71836       {
71837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71838       };
71839     }
71840   }
71841 }
71842
71843
71844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
71845   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71846   unsigned int arg2 ;
71847   std::vector< Dali::Actor > *arg3 = 0 ;
71848
71849   arg1 = (Dali::Toolkit::TableView *)jarg1;
71850   arg2 = (unsigned int)jarg2;
71851   arg3 = (std::vector< Dali::Actor > *)jarg3;
71852   if (!arg3) {
71853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
71854     return ;
71855   }
71856   {
71857     try {
71858       (arg1)->DeleteRow(arg2,*arg3);
71859     } catch (std::out_of_range& e) {
71860       {
71861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71862       };
71863     } catch (std::exception& e) {
71864       {
71865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71866       };
71867     } catch (...) {
71868       {
71869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71870       };
71871     }
71872   }
71873 }
71874
71875
71876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
71877   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71878   unsigned int arg2 ;
71879
71880   arg1 = (Dali::Toolkit::TableView *)jarg1;
71881   arg2 = (unsigned int)jarg2;
71882   {
71883     try {
71884       (arg1)->InsertColumn(arg2);
71885     } catch (std::out_of_range& e) {
71886       {
71887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71888       };
71889     } catch (std::exception& e) {
71890       {
71891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71892       };
71893     } catch (...) {
71894       {
71895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71896       };
71897     }
71898   }
71899 }
71900
71901
71902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
71903   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71904   unsigned int arg2 ;
71905
71906   arg1 = (Dali::Toolkit::TableView *)jarg1;
71907   arg2 = (unsigned int)jarg2;
71908   {
71909     try {
71910       (arg1)->DeleteColumn(arg2);
71911     } catch (std::out_of_range& e) {
71912       {
71913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71914       };
71915     } catch (std::exception& e) {
71916       {
71917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71918       };
71919     } catch (...) {
71920       {
71921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71922       };
71923     }
71924   }
71925 }
71926
71927
71928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
71929   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71930   unsigned int arg2 ;
71931   std::vector< Dali::Actor > *arg3 = 0 ;
71932
71933   arg1 = (Dali::Toolkit::TableView *)jarg1;
71934   arg2 = (unsigned int)jarg2;
71935   arg3 = (std::vector< Dali::Actor > *)jarg3;
71936   if (!arg3) {
71937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
71938     return ;
71939   }
71940   {
71941     try {
71942       (arg1)->DeleteColumn(arg2,*arg3);
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_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
71961   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71962   unsigned int arg2 ;
71963   unsigned int arg3 ;
71964
71965   arg1 = (Dali::Toolkit::TableView *)jarg1;
71966   arg2 = (unsigned int)jarg2;
71967   arg3 = (unsigned int)jarg3;
71968   {
71969     try {
71970       (arg1)->Resize(arg2,arg3);
71971     } catch (std::out_of_range& e) {
71972       {
71973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71974       };
71975     } catch (std::exception& e) {
71976       {
71977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71978       };
71979     } catch (...) {
71980       {
71981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71982       };
71983     }
71984   }
71985 }
71986
71987
71988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
71989   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71990   unsigned int arg2 ;
71991   unsigned int arg3 ;
71992   std::vector< Dali::Actor > *arg4 = 0 ;
71993
71994   arg1 = (Dali::Toolkit::TableView *)jarg1;
71995   arg2 = (unsigned int)jarg2;
71996   arg3 = (unsigned int)jarg3;
71997   arg4 = (std::vector< Dali::Actor > *)jarg4;
71998   if (!arg4) {
71999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
72000     return ;
72001   }
72002   {
72003     try {
72004       (arg1)->Resize(arg2,arg3,*arg4);
72005     } catch (std::out_of_range& e) {
72006       {
72007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72008       };
72009     } catch (std::exception& e) {
72010       {
72011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72012       };
72013     } catch (...) {
72014       {
72015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72016       };
72017     }
72018   }
72019 }
72020
72021
72022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
72023   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72024   Dali::Size arg2 ;
72025   Dali::Size *argp2 ;
72026
72027   arg1 = (Dali::Toolkit::TableView *)jarg1;
72028   argp2 = (Dali::Size *)jarg2;
72029   if (!argp2) {
72030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
72031     return ;
72032   }
72033   arg2 = *argp2;
72034   {
72035     try {
72036       (arg1)->SetCellPadding(arg2);
72037     } catch (std::out_of_range& e) {
72038       {
72039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72040       };
72041     } catch (std::exception& e) {
72042       {
72043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72044       };
72045     } catch (...) {
72046       {
72047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72048       };
72049     }
72050   }
72051 }
72052
72053
72054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
72055   void * jresult ;
72056   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72057   Dali::Size result;
72058
72059   arg1 = (Dali::Toolkit::TableView *)jarg1;
72060   {
72061     try {
72062       result = (arg1)->GetCellPadding();
72063     } catch (std::out_of_range& e) {
72064       {
72065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72066       };
72067     } catch (std::exception& e) {
72068       {
72069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72070       };
72071     } catch (...) {
72072       {
72073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72074       };
72075     }
72076   }
72077   jresult = new Dali::Size((const Dali::Size &)result);
72078   return jresult;
72079 }
72080
72081
72082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
72083   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72084   unsigned int arg2 ;
72085
72086   arg1 = (Dali::Toolkit::TableView *)jarg1;
72087   arg2 = (unsigned int)jarg2;
72088   {
72089     try {
72090       (arg1)->SetFitHeight(arg2);
72091     } catch (std::out_of_range& e) {
72092       {
72093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72094       };
72095     } catch (std::exception& e) {
72096       {
72097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72098       };
72099     } catch (...) {
72100       {
72101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72102       };
72103     }
72104   }
72105 }
72106
72107
72108 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
72109   unsigned int jresult ;
72110   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72111   unsigned int arg2 ;
72112   bool result;
72113
72114   arg1 = (Dali::Toolkit::TableView *)jarg1;
72115   arg2 = (unsigned int)jarg2;
72116   {
72117     try {
72118       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
72119     } catch (std::out_of_range& e) {
72120       {
72121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72122       };
72123     } catch (std::exception& e) {
72124       {
72125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72126       };
72127     } catch (...) {
72128       {
72129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72130       };
72131     }
72132   }
72133   jresult = result;
72134   return jresult;
72135 }
72136
72137
72138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
72139   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72140   unsigned int arg2 ;
72141
72142   arg1 = (Dali::Toolkit::TableView *)jarg1;
72143   arg2 = (unsigned int)jarg2;
72144   {
72145     try {
72146       (arg1)->SetFitWidth(arg2);
72147     } catch (std::out_of_range& e) {
72148       {
72149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72150       };
72151     } catch (std::exception& e) {
72152       {
72153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72154       };
72155     } catch (...) {
72156       {
72157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72158       };
72159     }
72160   }
72161 }
72162
72163
72164 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
72165   unsigned int jresult ;
72166   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72167   unsigned int arg2 ;
72168   bool result;
72169
72170   arg1 = (Dali::Toolkit::TableView *)jarg1;
72171   arg2 = (unsigned int)jarg2;
72172   {
72173     try {
72174       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
72175     } catch (std::out_of_range& e) {
72176       {
72177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72178       };
72179     } catch (std::exception& e) {
72180       {
72181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72182       };
72183     } catch (...) {
72184       {
72185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72186       };
72187     }
72188   }
72189   jresult = result;
72190   return jresult;
72191 }
72192
72193
72194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
72195   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72196   unsigned int arg2 ;
72197   float arg3 ;
72198
72199   arg1 = (Dali::Toolkit::TableView *)jarg1;
72200   arg2 = (unsigned int)jarg2;
72201   arg3 = (float)jarg3;
72202   {
72203     try {
72204       (arg1)->SetFixedHeight(arg2,arg3);
72205     } catch (std::out_of_range& e) {
72206       {
72207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72208       };
72209     } catch (std::exception& e) {
72210       {
72211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72212       };
72213     } catch (...) {
72214       {
72215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72216       };
72217     }
72218   }
72219 }
72220
72221
72222 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
72223   float jresult ;
72224   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72225   unsigned int arg2 ;
72226   float result;
72227
72228   arg1 = (Dali::Toolkit::TableView *)jarg1;
72229   arg2 = (unsigned int)jarg2;
72230   {
72231     try {
72232       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
72233     } catch (std::out_of_range& e) {
72234       {
72235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72236       };
72237     } catch (std::exception& e) {
72238       {
72239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72240       };
72241     } catch (...) {
72242       {
72243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72244       };
72245     }
72246   }
72247   jresult = result;
72248   return jresult;
72249 }
72250
72251
72252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
72253   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72254   unsigned int arg2 ;
72255   float arg3 ;
72256
72257   arg1 = (Dali::Toolkit::TableView *)jarg1;
72258   arg2 = (unsigned int)jarg2;
72259   arg3 = (float)jarg3;
72260   {
72261     try {
72262       (arg1)->SetRelativeHeight(arg2,arg3);
72263     } catch (std::out_of_range& e) {
72264       {
72265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72266       };
72267     } catch (std::exception& e) {
72268       {
72269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72270       };
72271     } catch (...) {
72272       {
72273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72274       };
72275     }
72276   }
72277 }
72278
72279
72280 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
72281   float jresult ;
72282   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72283   unsigned int arg2 ;
72284   float result;
72285
72286   arg1 = (Dali::Toolkit::TableView *)jarg1;
72287   arg2 = (unsigned int)jarg2;
72288   {
72289     try {
72290       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
72291     } catch (std::out_of_range& e) {
72292       {
72293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72294       };
72295     } catch (std::exception& e) {
72296       {
72297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72298       };
72299     } catch (...) {
72300       {
72301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72302       };
72303     }
72304   }
72305   jresult = result;
72306   return jresult;
72307 }
72308
72309
72310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
72311   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72312   unsigned int arg2 ;
72313   float arg3 ;
72314
72315   arg1 = (Dali::Toolkit::TableView *)jarg1;
72316   arg2 = (unsigned int)jarg2;
72317   arg3 = (float)jarg3;
72318   {
72319     try {
72320       (arg1)->SetFixedWidth(arg2,arg3);
72321     } catch (std::out_of_range& e) {
72322       {
72323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72324       };
72325     } catch (std::exception& e) {
72326       {
72327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72328       };
72329     } catch (...) {
72330       {
72331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72332       };
72333     }
72334   }
72335 }
72336
72337
72338 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
72339   float jresult ;
72340   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72341   unsigned int arg2 ;
72342   float result;
72343
72344   arg1 = (Dali::Toolkit::TableView *)jarg1;
72345   arg2 = (unsigned int)jarg2;
72346   {
72347     try {
72348       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(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 = result;
72364   return jresult;
72365 }
72366
72367
72368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
72369   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72370   unsigned int arg2 ;
72371   float arg3 ;
72372
72373   arg1 = (Dali::Toolkit::TableView *)jarg1;
72374   arg2 = (unsigned int)jarg2;
72375   arg3 = (float)jarg3;
72376   {
72377     try {
72378       (arg1)->SetRelativeWidth(arg2,arg3);
72379     } catch (std::out_of_range& e) {
72380       {
72381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72382       };
72383     } catch (std::exception& e) {
72384       {
72385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72386       };
72387     } catch (...) {
72388       {
72389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72390       };
72391     }
72392   }
72393 }
72394
72395
72396 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
72397   float jresult ;
72398   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72399   unsigned int arg2 ;
72400   float result;
72401
72402   arg1 = (Dali::Toolkit::TableView *)jarg1;
72403   arg2 = (unsigned int)jarg2;
72404   {
72405     try {
72406       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
72407     } catch (std::out_of_range& e) {
72408       {
72409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72410       };
72411     } catch (std::exception& e) {
72412       {
72413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72414       };
72415     } catch (...) {
72416       {
72417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72418       };
72419     }
72420   }
72421   jresult = result;
72422   return jresult;
72423 }
72424
72425
72426 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
72427   unsigned int jresult ;
72428   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72429   unsigned int result;
72430
72431   arg1 = (Dali::Toolkit::TableView *)jarg1;
72432   {
72433     try {
72434       result = (unsigned int)(arg1)->GetRows();
72435     } catch (std::out_of_range& e) {
72436       {
72437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72438       };
72439     } catch (std::exception& e) {
72440       {
72441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72442       };
72443     } catch (...) {
72444       {
72445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72446       };
72447     }
72448   }
72449   jresult = result;
72450   return jresult;
72451 }
72452
72453
72454 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
72455   unsigned int jresult ;
72456   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72457   unsigned int result;
72458
72459   arg1 = (Dali::Toolkit::TableView *)jarg1;
72460   {
72461     try {
72462       result = (unsigned int)(arg1)->GetColumns();
72463     } catch (std::out_of_range& e) {
72464       {
72465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72466       };
72467     } catch (std::exception& e) {
72468       {
72469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72470       };
72471     } catch (...) {
72472       {
72473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72474       };
72475     }
72476   }
72477   jresult = result;
72478   return jresult;
72479 }
72480
72481
72482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
72483   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72484   Dali::Toolkit::TableView::CellPosition arg2 ;
72485   Dali::HorizontalAlignment::Type arg3 ;
72486   Dali::VerticalAlignment::Type arg4 ;
72487   Dali::Toolkit::TableView::CellPosition *argp2 ;
72488
72489   arg1 = (Dali::Toolkit::TableView *)jarg1;
72490   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
72491   if (!argp2) {
72492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
72493     return ;
72494   }
72495   arg2 = *argp2;
72496   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
72497   arg4 = (Dali::VerticalAlignment::Type)jarg4;
72498   {
72499     try {
72500       (arg1)->SetCellAlignment(arg2,arg3,arg4);
72501     } catch (std::out_of_range& e) {
72502       {
72503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72504       };
72505     } catch (std::exception& e) {
72506       {
72507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72508       };
72509     } catch (...) {
72510       {
72511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72512       };
72513     }
72514   }
72515 }
72516
72517
72518 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
72519   unsigned int jresult ;
72520   unsigned int result;
72521
72522   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
72523   jresult = result;
72524   return jresult;
72525 }
72526
72527
72528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
72529   int jresult ;
72530   int result;
72531
72532   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
72533   jresult = (int)result;
72534   return jresult;
72535 }
72536
72537
72538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
72539   int jresult ;
72540   int result;
72541
72542   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
72543   jresult = (int)result;
72544   return jresult;
72545 }
72546
72547
72548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
72549   int jresult ;
72550   int result;
72551
72552   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
72553   jresult = (int)result;
72554   return jresult;
72555 }
72556
72557
72558 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
72559   int jresult ;
72560   int result;
72561
72562   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
72563   jresult = (int)result;
72564   return jresult;
72565 }
72566
72567
72568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
72569   int jresult ;
72570   int result;
72571
72572   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
72573   jresult = (int)result;
72574   return jresult;
72575 }
72576
72577
72578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
72579   int jresult ;
72580   int result;
72581
72582   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
72583   jresult = (int)result;
72584   return jresult;
72585 }
72586
72587
72588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
72589   int jresult ;
72590   int result;
72591
72592   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
72593   jresult = (int)result;
72594   return jresult;
72595 }
72596
72597
72598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
72599   int jresult ;
72600   int result;
72601
72602   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
72603   jresult = (int)result;
72604   return jresult;
72605 }
72606
72607
72608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
72609   int jresult ;
72610   int result;
72611
72612   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
72613   jresult = (int)result;
72614   return jresult;
72615 }
72616
72617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_ANIMATABLE_get() {
72618   int jresult ;
72619   int result;
72620
72621   result = (int)Dali::Toolkit::DevelTextLabel::Property::TEXT_COLOR_ANIMATABLE;
72622   jresult = (int)result;
72623   return jresult;
72624 }
72625
72626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
72627   int jresult ;
72628   int result;
72629
72630   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
72631   jresult = (int)result;
72632   return jresult;
72633 }
72634
72635
72636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
72637   int jresult ;
72638   int result;
72639
72640   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
72641   jresult = (int)result;
72642   return jresult;
72643 }
72644
72645
72646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
72647   int jresult ;
72648   int result;
72649
72650   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
72651   jresult = (int)result;
72652   return jresult;
72653 }
72654
72655
72656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
72657   int jresult ;
72658   int result;
72659
72660   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
72661   jresult = (int)result;
72662   return jresult;
72663 }
72664
72665
72666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
72667   int jresult ;
72668   int result;
72669
72670   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
72671   jresult = (int)result;
72672   return jresult;
72673 }
72674
72675
72676 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
72677   int jresult ;
72678   int result;
72679
72680   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
72681   jresult = (int)result;
72682   return jresult;
72683 }
72684
72685
72686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
72687   int jresult ;
72688   int result;
72689
72690   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
72691   jresult = (int)result;
72692   return jresult;
72693 }
72694
72695
72696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
72697   int jresult ;
72698   int result;
72699
72700   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
72701   jresult = (int)result;
72702   return jresult;
72703 }
72704
72705
72706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
72707   int jresult ;
72708   int result;
72709
72710   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
72711   jresult = (int)result;
72712   return jresult;
72713 }
72714
72715
72716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
72717   int jresult ;
72718   int result;
72719
72720   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
72721   jresult = (int)result;
72722   return jresult;
72723 }
72724
72725
72726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
72727   int jresult ;
72728   int result;
72729
72730   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
72731   jresult = (int)result;
72732   return jresult;
72733 }
72734
72735
72736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
72737   int jresult ;
72738   int result;
72739
72740   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
72741   jresult = (int)result;
72742   return jresult;
72743 }
72744
72745
72746 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
72747   int jresult ;
72748   int result;
72749
72750   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
72751   jresult = (int)result;
72752   return jresult;
72753 }
72754
72755
72756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
72757   int jresult ;
72758   int result;
72759
72760   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
72761   jresult = (int)result;
72762   return jresult;
72763 }
72764
72765
72766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
72767   int jresult ;
72768   int result;
72769
72770   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
72771   jresult = (int)result;
72772   return jresult;
72773 }
72774
72775
72776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
72777   void * jresult ;
72778   Dali::Toolkit::TextLabel::Property *result = 0 ;
72779
72780   {
72781     try {
72782       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
72783     } catch (std::out_of_range& e) {
72784       {
72785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72786       };
72787     } catch (std::exception& e) {
72788       {
72789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72790       };
72791     } catch (...) {
72792       {
72793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72794       };
72795     }
72796   }
72797   jresult = (void *)result;
72798   return jresult;
72799 }
72800
72801
72802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
72803   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
72804
72805   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
72806   {
72807     try {
72808       delete arg1;
72809     } catch (std::out_of_range& e) {
72810       {
72811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72812       };
72813     } catch (std::exception& e) {
72814       {
72815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72816       };
72817     } catch (...) {
72818       {
72819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72820       };
72821     }
72822   }
72823 }
72824
72825
72826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
72827   void * jresult ;
72828   Dali::Toolkit::TextLabel result;
72829
72830   {
72831     try {
72832       result = Dali::Toolkit::TextLabel::New();
72833     } catch (std::out_of_range& e) {
72834       {
72835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72836       };
72837     } catch (std::exception& e) {
72838       {
72839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72840       };
72841     } catch (...) {
72842       {
72843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72844       };
72845     }
72846   }
72847   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
72848   return jresult;
72849 }
72850
72851
72852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
72853   void * jresult ;
72854   std::string *arg1 = 0 ;
72855   Dali::Toolkit::TextLabel result;
72856
72857   if (!jarg1) {
72858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72859     return 0;
72860   }
72861   std::string arg1_str(jarg1);
72862   arg1 = &arg1_str;
72863   {
72864     try {
72865       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
72866     } catch (std::out_of_range& e) {
72867       {
72868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72869       };
72870     } catch (std::exception& e) {
72871       {
72872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72873       };
72874     } catch (...) {
72875       {
72876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72877       };
72878     }
72879   }
72880   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
72881
72882   //argout typemap for const std::string&
72883
72884   return jresult;
72885 }
72886
72887
72888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
72889   void * jresult ;
72890   Dali::Toolkit::TextLabel *result = 0 ;
72891
72892   {
72893     try {
72894       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
72895     } catch (std::out_of_range& e) {
72896       {
72897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72898       };
72899     } catch (std::exception& e) {
72900       {
72901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72902       };
72903     } catch (...) {
72904       {
72905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72906       };
72907     }
72908   }
72909   jresult = (void *)result;
72910   return jresult;
72911 }
72912
72913
72914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
72915   void * jresult ;
72916   Dali::Toolkit::TextLabel *arg1 = 0 ;
72917   Dali::Toolkit::TextLabel *result = 0 ;
72918
72919   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
72920   if (!arg1) {
72921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
72922     return 0;
72923   }
72924   {
72925     try {
72926       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
72927     } catch (std::out_of_range& e) {
72928       {
72929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72930       };
72931     } catch (std::exception& e) {
72932       {
72933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72934       };
72935     } catch (...) {
72936       {
72937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72938       };
72939     }
72940   }
72941   jresult = (void *)result;
72942   return jresult;
72943 }
72944
72945
72946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
72947   void * jresult ;
72948   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
72949   Dali::Toolkit::TextLabel *arg2 = 0 ;
72950   Dali::Toolkit::TextLabel *result = 0 ;
72951
72952   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
72953   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
72954   if (!arg2) {
72955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
72956     return 0;
72957   }
72958   {
72959     try {
72960       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
72961     } catch (std::out_of_range& e) {
72962       {
72963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72964       };
72965     } catch (std::exception& e) {
72966       {
72967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72968       };
72969     } catch (...) {
72970       {
72971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72972       };
72973     }
72974   }
72975   jresult = (void *)result;
72976   return jresult;
72977 }
72978
72979
72980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
72981   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
72982
72983   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
72984   {
72985     try {
72986       delete arg1;
72987     } catch (std::out_of_range& e) {
72988       {
72989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72990       };
72991     } catch (std::exception& e) {
72992       {
72993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72994       };
72995     } catch (...) {
72996       {
72997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72998       };
72999     }
73000   }
73001 }
73002
73003
73004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
73005   void * jresult ;
73006   Dali::BaseHandle arg1 ;
73007   Dali::BaseHandle *argp1 ;
73008   Dali::Toolkit::TextLabel result;
73009
73010   argp1 = (Dali::BaseHandle *)jarg1;
73011   if (!argp1) {
73012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73013     return 0;
73014   }
73015   arg1 = *argp1;
73016   {
73017     try {
73018       result = Dali::Toolkit::TextLabel::DownCast(arg1);
73019     } catch (std::out_of_range& e) {
73020       {
73021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73022       };
73023     } catch (std::exception& e) {
73024       {
73025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73026       };
73027     } catch (...) {
73028       {
73029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73030       };
73031     }
73032   }
73033   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
73034   return jresult;
73035 }
73036
73037
73038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
73039   void * jresult ;
73040   Dali::Toolkit::AccessibilityManager *result = 0 ;
73041
73042   {
73043     try {
73044       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
73045     } catch (std::out_of_range& e) {
73046       {
73047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73048       };
73049     } catch (std::exception& e) {
73050       {
73051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73052       };
73053     } catch (...) {
73054       {
73055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73056       };
73057     }
73058   }
73059   jresult = (void *)result;
73060   return jresult;
73061 }
73062
73063
73064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
73065   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73066
73067   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73068   {
73069     try {
73070       delete arg1;
73071     } catch (std::out_of_range& e) {
73072       {
73073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73074       };
73075     } catch (std::exception& e) {
73076       {
73077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73078       };
73079     } catch (...) {
73080       {
73081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73082       };
73083     }
73084   }
73085 }
73086
73087
73088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
73089   void * jresult ;
73090   Dali::Toolkit::AccessibilityManager result;
73091
73092   {
73093     try {
73094       result = Dali::Toolkit::AccessibilityManager::Get();
73095     } catch (std::out_of_range& e) {
73096       {
73097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73098       };
73099     } catch (std::exception& e) {
73100       {
73101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73102       };
73103     } catch (...) {
73104       {
73105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73106       };
73107     }
73108   }
73109   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
73110   return jresult;
73111 }
73112
73113
73114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
73115   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73116   Dali::Actor arg2 ;
73117   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
73118   std::string *arg4 = 0 ;
73119   Dali::Actor *argp2 ;
73120
73121   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73122   argp2 = (Dali::Actor *)jarg2;
73123   if (!argp2) {
73124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73125     return ;
73126   }
73127   arg2 = *argp2;
73128   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
73129   if (!jarg4) {
73130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
73131     return ;
73132   }
73133   std::string arg4_str(jarg4);
73134   arg4 = &arg4_str;
73135   {
73136     try {
73137       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
73138     } catch (std::out_of_range& e) {
73139       {
73140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73141       };
73142     } catch (std::exception& e) {
73143       {
73144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73145       };
73146     } catch (...) {
73147       {
73148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73149       };
73150     }
73151   }
73152
73153   //argout typemap for const std::string&
73154
73155 }
73156
73157
73158 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
73159   char * jresult ;
73160   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73161   Dali::Actor arg2 ;
73162   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
73163   Dali::Actor *argp2 ;
73164   std::string result;
73165
73166   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73167   argp2 = (Dali::Actor *)jarg2;
73168   if (!argp2) {
73169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73170     return 0;
73171   }
73172   arg2 = *argp2;
73173   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
73174   {
73175     try {
73176       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
73177     } catch (std::out_of_range& e) {
73178       {
73179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73180       };
73181     } catch (std::exception& e) {
73182       {
73183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73184       };
73185     } catch (...) {
73186       {
73187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73188       };
73189     }
73190   }
73191   jresult = SWIG_csharp_string_callback((&result)->c_str());
73192   return jresult;
73193 }
73194
73195
73196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
73197   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73198   Dali::Actor arg2 ;
73199   unsigned int arg3 ;
73200   Dali::Actor *argp2 ;
73201
73202   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73203   argp2 = (Dali::Actor *)jarg2;
73204   if (!argp2) {
73205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73206     return ;
73207   }
73208   arg2 = *argp2;
73209   arg3 = (unsigned int)jarg3;
73210   {
73211     try {
73212       (arg1)->SetFocusOrder(arg2,arg3);
73213     } catch (std::out_of_range& e) {
73214       {
73215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73216       };
73217     } catch (std::exception& e) {
73218       {
73219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73220       };
73221     } catch (...) {
73222       {
73223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73224       };
73225     }
73226   }
73227 }
73228
73229
73230 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
73231   unsigned int jresult ;
73232   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73233   Dali::Actor arg2 ;
73234   Dali::Actor *argp2 ;
73235   unsigned int result;
73236
73237   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73238   argp2 = (Dali::Actor *)jarg2;
73239   if (!argp2) {
73240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73241     return 0;
73242   }
73243   arg2 = *argp2;
73244   {
73245     try {
73246       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
73247     } catch (std::out_of_range& e) {
73248       {
73249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73250       };
73251     } catch (std::exception& e) {
73252       {
73253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73254       };
73255     } catch (...) {
73256       {
73257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73258       };
73259     }
73260   }
73261   jresult = result;
73262   return jresult;
73263 }
73264
73265
73266 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
73267   unsigned int jresult ;
73268   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73269   unsigned int result;
73270
73271   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73272   {
73273     try {
73274       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
73275     } catch (std::out_of_range& e) {
73276       {
73277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73278       };
73279     } catch (std::exception& e) {
73280       {
73281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73282       };
73283     } catch (...) {
73284       {
73285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73286       };
73287     }
73288   }
73289   jresult = result;
73290   return jresult;
73291 }
73292
73293
73294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
73295   void * jresult ;
73296   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73297   unsigned int arg2 ;
73298   Dali::Actor result;
73299
73300   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73301   arg2 = (unsigned int)jarg2;
73302   {
73303     try {
73304       result = (arg1)->GetActorByFocusOrder(arg2);
73305     } catch (std::out_of_range& e) {
73306       {
73307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73308       };
73309     } catch (std::exception& e) {
73310       {
73311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73312       };
73313     } catch (...) {
73314       {
73315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73316       };
73317     }
73318   }
73319   jresult = new Dali::Actor((const Dali::Actor &)result);
73320   return jresult;
73321 }
73322
73323
73324 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
73325   unsigned int jresult ;
73326   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73327   Dali::Actor arg2 ;
73328   Dali::Actor *argp2 ;
73329   bool result;
73330
73331   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73332   argp2 = (Dali::Actor *)jarg2;
73333   if (!argp2) {
73334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73335     return 0;
73336   }
73337   arg2 = *argp2;
73338   {
73339     try {
73340       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
73341     } catch (std::out_of_range& e) {
73342       {
73343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73344       };
73345     } catch (std::exception& e) {
73346       {
73347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73348       };
73349     } catch (...) {
73350       {
73351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73352       };
73353     }
73354   }
73355   jresult = result;
73356   return jresult;
73357 }
73358
73359
73360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
73361   void * jresult ;
73362   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73363   Dali::Actor result;
73364
73365   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73366   {
73367     try {
73368       result = (arg1)->GetCurrentFocusActor();
73369     } catch (std::out_of_range& e) {
73370       {
73371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73372       };
73373     } catch (std::exception& e) {
73374       {
73375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73376       };
73377     } catch (...) {
73378       {
73379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73380       };
73381     }
73382   }
73383   jresult = new Dali::Actor((const Dali::Actor &)result);
73384   return jresult;
73385 }
73386
73387
73388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
73389   void * jresult ;
73390   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73391   Dali::Actor result;
73392
73393   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73394   {
73395     try {
73396       result = (arg1)->GetCurrentFocusGroup();
73397     } catch (std::out_of_range& e) {
73398       {
73399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73400       };
73401     } catch (std::exception& e) {
73402       {
73403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73404       };
73405     } catch (...) {
73406       {
73407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73408       };
73409     }
73410   }
73411   jresult = new Dali::Actor((const Dali::Actor &)result);
73412   return jresult;
73413 }
73414
73415
73416 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
73417   unsigned int jresult ;
73418   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73419   unsigned int result;
73420
73421   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73422   {
73423     try {
73424       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
73425     } catch (std::out_of_range& e) {
73426       {
73427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73428       };
73429     } catch (std::exception& e) {
73430       {
73431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73432       };
73433     } catch (...) {
73434       {
73435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73436       };
73437     }
73438   }
73439   jresult = result;
73440   return jresult;
73441 }
73442
73443
73444 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
73445   unsigned int jresult ;
73446   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73447   bool result;
73448
73449   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73450   {
73451     try {
73452       result = (bool)(arg1)->MoveFocusForward();
73453     } catch (std::out_of_range& e) {
73454       {
73455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73456       };
73457     } catch (std::exception& e) {
73458       {
73459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73460       };
73461     } catch (...) {
73462       {
73463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73464       };
73465     }
73466   }
73467   jresult = result;
73468   return jresult;
73469 }
73470
73471
73472 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
73473   unsigned int jresult ;
73474   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73475   bool result;
73476
73477   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73478   {
73479     try {
73480       result = (bool)(arg1)->MoveFocusBackward();
73481     } catch (std::out_of_range& e) {
73482       {
73483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73484       };
73485     } catch (std::exception& e) {
73486       {
73487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73488       };
73489     } catch (...) {
73490       {
73491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73492       };
73493     }
73494   }
73495   jresult = result;
73496   return jresult;
73497 }
73498
73499
73500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
73501   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73502
73503   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73504   {
73505     try {
73506       (arg1)->ClearFocus();
73507     } catch (std::out_of_range& e) {
73508       {
73509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73510       };
73511     } catch (std::exception& e) {
73512       {
73513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73514       };
73515     } catch (...) {
73516       {
73517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73518       };
73519     }
73520   }
73521 }
73522
73523
73524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
73525   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73526
73527   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73528   {
73529     try {
73530       (arg1)->Reset();
73531     } catch (std::out_of_range& e) {
73532       {
73533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73534       };
73535     } catch (std::exception& e) {
73536       {
73537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73538       };
73539     } catch (...) {
73540       {
73541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73542       };
73543     }
73544   }
73545 }
73546
73547
73548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
73549   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73550   Dali::Actor arg2 ;
73551   bool arg3 ;
73552   Dali::Actor *argp2 ;
73553
73554   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73555   argp2 = (Dali::Actor *)jarg2;
73556   if (!argp2) {
73557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73558     return ;
73559   }
73560   arg2 = *argp2;
73561   arg3 = jarg3 ? true : false;
73562   {
73563     try {
73564       (arg1)->SetFocusGroup(arg2,arg3);
73565     } catch (std::out_of_range& e) {
73566       {
73567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73568       };
73569     } catch (std::exception& e) {
73570       {
73571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73572       };
73573     } catch (...) {
73574       {
73575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73576       };
73577     }
73578   }
73579 }
73580
73581
73582 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
73583   unsigned int jresult ;
73584   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73585   Dali::Actor arg2 ;
73586   Dali::Actor *argp2 ;
73587   bool result;
73588
73589   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73590   argp2 = (Dali::Actor *)jarg2;
73591   if (!argp2) {
73592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73593     return 0;
73594   }
73595   arg2 = *argp2;
73596   {
73597     try {
73598       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
73599     } catch (std::out_of_range& e) {
73600       {
73601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73602       };
73603     } catch (std::exception& e) {
73604       {
73605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73606       };
73607     } catch (...) {
73608       {
73609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73610       };
73611     }
73612   }
73613   jresult = result;
73614   return jresult;
73615 }
73616
73617
73618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
73619   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73620   bool arg2 ;
73621
73622   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73623   arg2 = jarg2 ? true : false;
73624   {
73625     try {
73626       (arg1)->SetGroupMode(arg2);
73627     } catch (std::out_of_range& e) {
73628       {
73629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73630       };
73631     } catch (std::exception& e) {
73632       {
73633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73634       };
73635     } catch (...) {
73636       {
73637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73638       };
73639     }
73640   }
73641 }
73642
73643
73644 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
73645   unsigned int jresult ;
73646   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73647   bool result;
73648
73649   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73650   {
73651     try {
73652       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
73653     } catch (std::out_of_range& e) {
73654       {
73655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73656       };
73657     } catch (std::exception& e) {
73658       {
73659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73660       };
73661     } catch (...) {
73662       {
73663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73664       };
73665     }
73666   }
73667   jresult = result;
73668   return jresult;
73669 }
73670
73671
73672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
73673   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73674   bool arg2 ;
73675
73676   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73677   arg2 = jarg2 ? true : false;
73678   {
73679     try {
73680       (arg1)->SetWrapMode(arg2);
73681     } catch (std::out_of_range& e) {
73682       {
73683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73684       };
73685     } catch (std::exception& e) {
73686       {
73687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73688       };
73689     } catch (...) {
73690       {
73691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73692       };
73693     }
73694   }
73695 }
73696
73697
73698 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
73699   unsigned int jresult ;
73700   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73701   bool result;
73702
73703   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73704   {
73705     try {
73706       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
73707     } catch (std::out_of_range& e) {
73708       {
73709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73710       };
73711     } catch (std::exception& e) {
73712       {
73713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73714       };
73715     } catch (...) {
73716       {
73717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73718       };
73719     }
73720   }
73721   jresult = result;
73722   return jresult;
73723 }
73724
73725
73726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
73727   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73728   Dali::Actor arg2 ;
73729   Dali::Actor *argp2 ;
73730
73731   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73732   argp2 = (Dali::Actor *)jarg2;
73733   if (!argp2) {
73734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73735     return ;
73736   }
73737   arg2 = *argp2;
73738   {
73739     try {
73740       (arg1)->SetFocusIndicatorActor(arg2);
73741     } catch (std::out_of_range& e) {
73742       {
73743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73744       };
73745     } catch (std::exception& e) {
73746       {
73747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73748       };
73749     } catch (...) {
73750       {
73751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73752       };
73753     }
73754   }
73755 }
73756
73757
73758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
73759   void * jresult ;
73760   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73761   Dali::Actor result;
73762
73763   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73764   {
73765     try {
73766       result = (arg1)->GetFocusIndicatorActor();
73767     } catch (std::out_of_range& e) {
73768       {
73769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73770       };
73771     } catch (std::exception& e) {
73772       {
73773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73774       };
73775     } catch (...) {
73776       {
73777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73778       };
73779     }
73780   }
73781   jresult = new Dali::Actor((const Dali::Actor &)result);
73782   return jresult;
73783 }
73784
73785
73786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
73787   void * jresult ;
73788   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73789   Dali::Actor arg2 ;
73790   Dali::Actor *argp2 ;
73791   Dali::Actor result;
73792
73793   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73794   argp2 = (Dali::Actor *)jarg2;
73795   if (!argp2) {
73796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73797     return 0;
73798   }
73799   arg2 = *argp2;
73800   {
73801     try {
73802       result = (arg1)->GetFocusGroup(arg2);
73803     } catch (std::out_of_range& e) {
73804       {
73805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73806       };
73807     } catch (std::exception& e) {
73808       {
73809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73810       };
73811     } catch (...) {
73812       {
73813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73814       };
73815     }
73816   }
73817   jresult = new Dali::Actor((const Dali::Actor &)result);
73818   return jresult;
73819 }
73820
73821
73822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
73823   void * jresult ;
73824   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73825   Dali::Vector2 result;
73826
73827   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73828   {
73829     try {
73830       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
73831     } catch (std::out_of_range& e) {
73832       {
73833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73834       };
73835     } catch (std::exception& e) {
73836       {
73837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73838       };
73839     } catch (...) {
73840       {
73841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73842       };
73843     }
73844   }
73845   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
73846   return jresult;
73847 }
73848
73849
73850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
73851   void * jresult ;
73852   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73853   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
73854
73855   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73856   {
73857     try {
73858       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
73859     } catch (std::out_of_range& e) {
73860       {
73861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73862       };
73863     } catch (std::exception& e) {
73864       {
73865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73866       };
73867     } catch (...) {
73868       {
73869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73870       };
73871     }
73872   }
73873   jresult = (void *)result;
73874   return jresult;
73875 }
73876
73877
73878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
73879   void * jresult ;
73880   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73881   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
73882
73883   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73884   {
73885     try {
73886       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
73887     } catch (std::out_of_range& e) {
73888       {
73889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73890       };
73891     } catch (std::exception& e) {
73892       {
73893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73894       };
73895     } catch (...) {
73896       {
73897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73898       };
73899     }
73900   }
73901   jresult = (void *)result;
73902   return jresult;
73903 }
73904
73905
73906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
73907   void * jresult ;
73908   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73909   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
73910
73911   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73912   {
73913     try {
73914       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
73915     } catch (std::out_of_range& e) {
73916       {
73917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73918       };
73919     } catch (std::exception& e) {
73920       {
73921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73922       };
73923     } catch (...) {
73924       {
73925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73926       };
73927     }
73928   }
73929   jresult = (void *)result;
73930   return jresult;
73931 }
73932
73933
73934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
73935   void * jresult ;
73936   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73937   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
73938
73939   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73940   {
73941     try {
73942       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
73943     } catch (std::out_of_range& e) {
73944       {
73945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73946       };
73947     } catch (std::exception& e) {
73948       {
73949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73950       };
73951     } catch (...) {
73952       {
73953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73954       };
73955     }
73956   }
73957   jresult = (void *)result;
73958   return jresult;
73959 }
73960
73961
73962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
73963   void * jresult ;
73964   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73965   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
73966
73967   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73968   {
73969     try {
73970       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
73971     } catch (std::out_of_range& e) {
73972       {
73973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73974       };
73975     } catch (std::exception& e) {
73976       {
73977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73978       };
73979     } catch (...) {
73980       {
73981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73982       };
73983     }
73984   }
73985   jresult = (void *)result;
73986   return jresult;
73987 }
73988
73989
73990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
73991   void * jresult ;
73992   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73993   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
73994
73995   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73996   {
73997     try {
73998       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
73999     } catch (std::out_of_range& e) {
74000       {
74001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74002       };
74003     } catch (std::exception& e) {
74004       {
74005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74006       };
74007     } catch (...) {
74008       {
74009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74010       };
74011     }
74012   }
74013   jresult = (void *)result;
74014   return jresult;
74015 }
74016
74017
74018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
74019   void * jresult ;
74020   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74021   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74022
74023   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74024   {
74025     try {
74026       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
74027     } catch (std::out_of_range& e) {
74028       {
74029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74030       };
74031     } catch (std::exception& e) {
74032       {
74033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74034       };
74035     } catch (...) {
74036       {
74037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74038       };
74039     }
74040   }
74041   jresult = (void *)result;
74042   return jresult;
74043 }
74044
74045
74046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
74047   void * jresult ;
74048   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74049   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74050
74051   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74052   {
74053     try {
74054       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
74055     } catch (std::out_of_range& e) {
74056       {
74057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74058       };
74059     } catch (std::exception& e) {
74060       {
74061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74062       };
74063     } catch (...) {
74064       {
74065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74066       };
74067     }
74068   }
74069   jresult = (void *)result;
74070   return jresult;
74071 }
74072
74073
74074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
74075   void * jresult ;
74076   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74077   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74078
74079   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74080   {
74081     try {
74082       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
74083     } catch (std::out_of_range& e) {
74084       {
74085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74086       };
74087     } catch (std::exception& e) {
74088       {
74089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74090       };
74091     } catch (...) {
74092       {
74093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74094       };
74095     }
74096   }
74097   jresult = (void *)result;
74098   return jresult;
74099 }
74100
74101
74102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
74103   void * jresult ;
74104   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74105   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74106
74107   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74108   {
74109     try {
74110       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
74111     } catch (std::out_of_range& e) {
74112       {
74113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74114       };
74115     } catch (std::exception& e) {
74116       {
74117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74118       };
74119     } catch (...) {
74120       {
74121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74122       };
74123     }
74124   }
74125   jresult = (void *)result;
74126   return jresult;
74127 }
74128
74129
74130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
74131   void * jresult ;
74132   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74133   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74134
74135   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74136   {
74137     try {
74138       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
74139     } catch (std::out_of_range& e) {
74140       {
74141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74142       };
74143     } catch (std::exception& e) {
74144       {
74145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74146       };
74147     } catch (...) {
74148       {
74149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74150       };
74151     }
74152   }
74153   jresult = (void *)result;
74154   return jresult;
74155 }
74156
74157
74158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
74159   void * jresult ;
74160   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74161   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74162
74163   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74164   {
74165     try {
74166       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
74167     } catch (std::out_of_range& e) {
74168       {
74169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74170       };
74171     } catch (std::exception& e) {
74172       {
74173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74174       };
74175     } catch (...) {
74176       {
74177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74178       };
74179     }
74180   }
74181   jresult = (void *)result;
74182   return jresult;
74183 }
74184
74185
74186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
74187   void * jresult ;
74188   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74189   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74190
74191   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74192   {
74193     try {
74194       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
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_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
74215   void * jresult ;
74216   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74217   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74218
74219   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74220   {
74221     try {
74222       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
74223     } catch (std::out_of_range& e) {
74224       {
74225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74226       };
74227     } catch (std::exception& e) {
74228       {
74229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74230       };
74231     } catch (...) {
74232       {
74233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74234       };
74235     }
74236   }
74237   jresult = (void *)result;
74238   return jresult;
74239 }
74240
74241
74242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
74243   void * jresult ;
74244   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74245   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74246
74247   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74248   {
74249     try {
74250       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
74251     } catch (std::out_of_range& e) {
74252       {
74253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74254       };
74255     } catch (std::exception& e) {
74256       {
74257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74258       };
74259     } catch (...) {
74260       {
74261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74262       };
74263     }
74264   }
74265   jresult = (void *)result;
74266   return jresult;
74267 }
74268
74269
74270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
74271   void * jresult ;
74272   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74273   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74274
74275   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74276   {
74277     try {
74278       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
74279     } catch (std::out_of_range& e) {
74280       {
74281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74282       };
74283     } catch (std::exception& e) {
74284       {
74285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74286       };
74287     } catch (...) {
74288       {
74289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74290       };
74291     }
74292   }
74293   jresult = (void *)result;
74294   return jresult;
74295 }
74296
74297
74298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
74299   void * jresult ;
74300   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74301   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74302
74303   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74304   {
74305     try {
74306       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
74307     } catch (std::out_of_range& e) {
74308       {
74309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74310       };
74311     } catch (std::exception& e) {
74312       {
74313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74314       };
74315     } catch (...) {
74316       {
74317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74318       };
74319     }
74320   }
74321   jresult = (void *)result;
74322   return jresult;
74323 }
74324
74325
74326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
74327   void * jresult ;
74328   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74329   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74330
74331   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74332   {
74333     try {
74334       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
74335     } catch (std::out_of_range& e) {
74336       {
74337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74338       };
74339     } catch (std::exception& e) {
74340       {
74341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74342       };
74343     } catch (...) {
74344       {
74345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74346       };
74347     }
74348   }
74349   jresult = (void *)result;
74350   return jresult;
74351 }
74352
74353
74354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
74355   void * jresult ;
74356   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74357   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74358
74359   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74360   {
74361     try {
74362       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
74363     } catch (std::out_of_range& e) {
74364       {
74365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74366       };
74367     } catch (std::exception& e) {
74368       {
74369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74370       };
74371     } catch (...) {
74372       {
74373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74374       };
74375     }
74376   }
74377   jresult = (void *)result;
74378   return jresult;
74379 }
74380
74381
74382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
74383   void * jresult ;
74384   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74385   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74386
74387   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74388   {
74389     try {
74390       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
74391     } catch (std::out_of_range& e) {
74392       {
74393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74394       };
74395     } catch (std::exception& e) {
74396       {
74397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74398       };
74399     } catch (...) {
74400       {
74401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74402       };
74403     }
74404   }
74405   jresult = (void *)result;
74406   return jresult;
74407 }
74408
74409
74410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
74411   void * jresult ;
74412   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74413   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74414
74415   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74416   {
74417     try {
74418       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
74419     } catch (std::out_of_range& e) {
74420       {
74421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74422       };
74423     } catch (std::exception& e) {
74424       {
74425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74426       };
74427     } catch (...) {
74428       {
74429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74430       };
74431     }
74432   }
74433   jresult = (void *)result;
74434   return jresult;
74435 }
74436
74437
74438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
74439   void * jresult ;
74440   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74441   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74442
74443   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74444   {
74445     try {
74446       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
74447     } catch (std::out_of_range& e) {
74448       {
74449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74450       };
74451     } catch (std::exception& e) {
74452       {
74453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74454       };
74455     } catch (...) {
74456       {
74457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74458       };
74459     }
74460   }
74461   jresult = (void *)result;
74462   return jresult;
74463 }
74464
74465
74466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
74467   void * jresult ;
74468   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74469   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74470
74471   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74472   {
74473     try {
74474       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
74475     } catch (std::out_of_range& e) {
74476       {
74477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74478       };
74479     } catch (std::exception& e) {
74480       {
74481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74482       };
74483     } catch (...) {
74484       {
74485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74486       };
74487     }
74488   }
74489   jresult = (void *)result;
74490   return jresult;
74491 }
74492
74493
74494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
74495   void * jresult ;
74496   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74497   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74498
74499   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74500   {
74501     try {
74502       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
74503     } catch (std::out_of_range& e) {
74504       {
74505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74506       };
74507     } catch (std::exception& e) {
74508       {
74509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74510       };
74511     } catch (...) {
74512       {
74513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74514       };
74515     }
74516   }
74517   jresult = (void *)result;
74518   return jresult;
74519 }
74520
74521
74522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
74523   void * jresult ;
74524   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74525   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74526
74527   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74528   {
74529     try {
74530       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
74531     } catch (std::out_of_range& e) {
74532       {
74533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74534       };
74535     } catch (std::exception& e) {
74536       {
74537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74538       };
74539     } catch (...) {
74540       {
74541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74542       };
74543     }
74544   }
74545   jresult = (void *)result;
74546   return jresult;
74547 }
74548
74549
74550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
74551   void * jresult ;
74552   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74553   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74554
74555   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74556   {
74557     try {
74558       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
74559     } catch (std::out_of_range& e) {
74560       {
74561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74562       };
74563     } catch (std::exception& e) {
74564       {
74565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74566       };
74567     } catch (...) {
74568       {
74569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74570       };
74571     }
74572   }
74573   jresult = (void *)result;
74574   return jresult;
74575 }
74576
74577
74578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
74579   void * jresult ;
74580   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74581   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74582
74583   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74584   {
74585     try {
74586       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
74587     } catch (std::out_of_range& e) {
74588       {
74589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74590       };
74591     } catch (std::exception& e) {
74592       {
74593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74594       };
74595     } catch (...) {
74596       {
74597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74598       };
74599     }
74600   }
74601   jresult = (void *)result;
74602   return jresult;
74603 }
74604
74605
74606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
74607   void * jresult ;
74608   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74609   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74610
74611   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74612   {
74613     try {
74614       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
74615     } catch (std::out_of_range& e) {
74616       {
74617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74618       };
74619     } catch (std::exception& e) {
74620       {
74621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74622       };
74623     } catch (...) {
74624       {
74625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74626       };
74627     }
74628   }
74629   jresult = (void *)result;
74630   return jresult;
74631 }
74632
74633
74634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
74635   void * jresult ;
74636   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74637   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74638
74639   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74640   {
74641     try {
74642       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
74643     } catch (std::out_of_range& e) {
74644       {
74645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74646       };
74647     } catch (std::exception& e) {
74648       {
74649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74650       };
74651     } catch (...) {
74652       {
74653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74654       };
74655     }
74656   }
74657   jresult = (void *)result;
74658   return jresult;
74659 }
74660
74661
74662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
74663   void * jresult ;
74664   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74665   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
74666
74667   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74668   {
74669     try {
74670       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
74671     } catch (std::out_of_range& e) {
74672       {
74673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74674       };
74675     } catch (std::exception& e) {
74676       {
74677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74678       };
74679     } catch (...) {
74680       {
74681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74682       };
74683     }
74684   }
74685   jresult = (void *)result;
74686   return jresult;
74687 }
74688
74689
74690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
74691   void * jresult ;
74692   Dali::Toolkit::StyleManager *result = 0 ;
74693
74694   {
74695     try {
74696       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
74697     } catch (std::out_of_range& e) {
74698       {
74699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74700       };
74701     } catch (std::exception& e) {
74702       {
74703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74704       };
74705     } catch (...) {
74706       {
74707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74708       };
74709     }
74710   }
74711   jresult = (void *)result;
74712   return jresult;
74713 }
74714
74715
74716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
74717   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74718
74719   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74720   {
74721     try {
74722       delete arg1;
74723     } catch (std::out_of_range& e) {
74724       {
74725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74726       };
74727     } catch (std::exception& e) {
74728       {
74729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74730       };
74731     } catch (...) {
74732       {
74733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74734       };
74735     }
74736   }
74737 }
74738
74739
74740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
74741   void * jresult ;
74742   Dali::Toolkit::StyleManager result;
74743
74744   {
74745     try {
74746       result = Dali::Toolkit::StyleManager::Get();
74747     } catch (std::out_of_range& e) {
74748       {
74749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74750       };
74751     } catch (std::exception& e) {
74752       {
74753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74754       };
74755     } catch (...) {
74756       {
74757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74758       };
74759     }
74760   }
74761   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
74762   return jresult;
74763 }
74764
74765
74766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
74767   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74768   std::string *arg2 = 0 ;
74769
74770   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74771   if (!jarg2) {
74772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
74773     return ;
74774   }
74775   std::string arg2_str(jarg2);
74776   arg2 = &arg2_str;
74777   {
74778     try {
74779       (arg1)->ApplyTheme((std::string const &)*arg2);
74780     } catch (std::out_of_range& e) {
74781       {
74782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74783       };
74784     } catch (std::exception& e) {
74785       {
74786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74787       };
74788     } catch (...) {
74789       {
74790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74791       };
74792     }
74793   }
74794
74795   //argout typemap for const std::string&
74796
74797 }
74798
74799
74800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
74801   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74802
74803   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74804   {
74805     try {
74806       (arg1)->ApplyDefaultTheme();
74807     } catch (std::out_of_range& e) {
74808       {
74809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74810       };
74811     } catch (std::exception& e) {
74812       {
74813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74814       };
74815     } catch (...) {
74816       {
74817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74818       };
74819     }
74820   }
74821 }
74822
74823
74824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
74825   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74826   std::string *arg2 = 0 ;
74827   Dali::Property::Value *arg3 = 0 ;
74828
74829   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74830   if (!jarg2) {
74831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
74832     return ;
74833   }
74834   std::string arg2_str(jarg2);
74835   arg2 = &arg2_str;
74836   arg3 = (Dali::Property::Value *)jarg3;
74837   if (!arg3) {
74838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
74839     return ;
74840   }
74841   {
74842     try {
74843       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
74844     } catch (std::out_of_range& e) {
74845       {
74846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74847       };
74848     } catch (std::exception& e) {
74849       {
74850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74851       };
74852     } catch (...) {
74853       {
74854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74855       };
74856     }
74857   }
74858
74859   //argout typemap for const std::string&
74860
74861 }
74862
74863
74864 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
74865   unsigned int jresult ;
74866   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74867   std::string *arg2 = 0 ;
74868   Dali::Property::Value *arg3 = 0 ;
74869   bool result;
74870
74871   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74872   if (!jarg2) {
74873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
74874     return 0;
74875   }
74876   std::string arg2_str(jarg2);
74877   arg2 = &arg2_str;
74878   arg3 = (Dali::Property::Value *)jarg3;
74879   if (!arg3) {
74880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
74881     return 0;
74882   }
74883   {
74884     try {
74885       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
74886     } catch (std::out_of_range& e) {
74887       {
74888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74889       };
74890     } catch (std::exception& e) {
74891       {
74892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74893       };
74894     } catch (...) {
74895       {
74896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74897       };
74898     }
74899   }
74900   jresult = result;
74901
74902   //argout typemap for const std::string&
74903
74904   return jresult;
74905 }
74906
74907
74908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
74909   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74910   Dali::Toolkit::Control arg2 ;
74911   std::string *arg3 = 0 ;
74912   std::string *arg4 = 0 ;
74913   Dali::Toolkit::Control *argp2 ;
74914
74915   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74916   argp2 = (Dali::Toolkit::Control *)jarg2;
74917   if (!argp2) {
74918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
74919     return ;
74920   }
74921   arg2 = *argp2;
74922   if (!jarg3) {
74923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
74924     return ;
74925   }
74926   std::string arg3_str(jarg3);
74927   arg3 = &arg3_str;
74928   if (!jarg4) {
74929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
74930     return ;
74931   }
74932   std::string arg4_str(jarg4);
74933   arg4 = &arg4_str;
74934   {
74935     try {
74936       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
74937     } catch (std::out_of_range& e) {
74938       {
74939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74940       };
74941     } catch (std::exception& e) {
74942       {
74943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74944       };
74945     } catch (...) {
74946       {
74947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74948       };
74949     }
74950   }
74951
74952   //argout typemap for const std::string&
74953
74954
74955   //argout typemap for const std::string&
74956
74957 }
74958
74959
74960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
74961   void * jresult ;
74962   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74963   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
74964
74965   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74966   {
74967     try {
74968       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
74969     } catch (std::out_of_range& e) {
74970       {
74971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74972       };
74973     } catch (std::exception& e) {
74974       {
74975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74976       };
74977     } catch (...) {
74978       {
74979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74980       };
74981     }
74982   }
74983   jresult = (void *)result;
74984   return jresult;
74985 }
74986
74987
74988 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
74989   int jresult ;
74990   int result;
74991
74992   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
74993   jresult = (int)result;
74994   return jresult;
74995 }
74996
74997
74998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
74999   int jresult ;
75000   int result;
75001
75002   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
75003   jresult = (int)result;
75004   return jresult;
75005 }
75006
75007
75008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
75009   int jresult ;
75010   int result;
75011
75012   result = (int)Dali::Toolkit::Slider::Property::VALUE;
75013   jresult = (int)result;
75014   return jresult;
75015 }
75016
75017
75018 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
75019   int jresult ;
75020   int result;
75021
75022   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
75023   jresult = (int)result;
75024   return jresult;
75025 }
75026
75027
75028 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
75029   int jresult ;
75030   int result;
75031
75032   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
75033   jresult = (int)result;
75034   return jresult;
75035 }
75036
75037
75038 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
75039   int jresult ;
75040   int result;
75041
75042   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
75043   jresult = (int)result;
75044   return jresult;
75045 }
75046
75047
75048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
75049   int jresult ;
75050   int result;
75051
75052   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
75053   jresult = (int)result;
75054   return jresult;
75055 }
75056
75057
75058 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
75059   int jresult ;
75060   int result;
75061
75062   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
75063   jresult = (int)result;
75064   return jresult;
75065 }
75066
75067
75068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
75069   int jresult ;
75070   int result;
75071
75072   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
75073   jresult = (int)result;
75074   return jresult;
75075 }
75076
75077
75078 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
75079   int jresult ;
75080   int result;
75081
75082   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
75083   jresult = (int)result;
75084   return jresult;
75085 }
75086
75087
75088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
75089   int jresult ;
75090   int result;
75091
75092   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
75093   jresult = (int)result;
75094   return jresult;
75095 }
75096
75097
75098 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
75099   int jresult ;
75100   int result;
75101
75102   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
75103   jresult = (int)result;
75104   return jresult;
75105 }
75106
75107
75108 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
75109   int jresult ;
75110   int result;
75111
75112   result = (int)Dali::Toolkit::Slider::Property::MARKS;
75113   jresult = (int)result;
75114   return jresult;
75115 }
75116
75117
75118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
75119   int jresult ;
75120   int result;
75121
75122   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
75123   jresult = (int)result;
75124   return jresult;
75125 }
75126
75127
75128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
75129   int jresult ;
75130   int result;
75131
75132   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
75133   jresult = (int)result;
75134   return jresult;
75135 }
75136
75137
75138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
75139   void * jresult ;
75140   Dali::Toolkit::Slider::Property *result = 0 ;
75141
75142   {
75143     try {
75144       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
75145     } catch (std::out_of_range& e) {
75146       {
75147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75148       };
75149     } catch (std::exception& e) {
75150       {
75151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75152       };
75153     } catch (...) {
75154       {
75155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75156       };
75157     }
75158   }
75159   jresult = (void *)result;
75160   return jresult;
75161 }
75162
75163
75164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
75165   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
75166
75167   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
75168   {
75169     try {
75170       delete arg1;
75171     } catch (std::out_of_range& e) {
75172       {
75173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75174       };
75175     } catch (std::exception& e) {
75176       {
75177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75178       };
75179     } catch (...) {
75180       {
75181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75182       };
75183     }
75184   }
75185 }
75186
75187
75188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
75189   void * jresult ;
75190   Dali::Toolkit::Slider result;
75191
75192   {
75193     try {
75194       result = Dali::Toolkit::Slider::New();
75195     } catch (std::out_of_range& e) {
75196       {
75197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75198       };
75199     } catch (std::exception& e) {
75200       {
75201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75202       };
75203     } catch (...) {
75204       {
75205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75206       };
75207     }
75208   }
75209   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
75210   return jresult;
75211 }
75212
75213
75214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
75215   void * jresult ;
75216   Dali::Toolkit::Slider *result = 0 ;
75217
75218   {
75219     try {
75220       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
75221     } catch (std::out_of_range& e) {
75222       {
75223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75224       };
75225     } catch (std::exception& e) {
75226       {
75227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75228       };
75229     } catch (...) {
75230       {
75231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75232       };
75233     }
75234   }
75235   jresult = (void *)result;
75236   return jresult;
75237 }
75238
75239
75240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
75241   void * jresult ;
75242   Dali::Toolkit::Slider *arg1 = 0 ;
75243   Dali::Toolkit::Slider *result = 0 ;
75244
75245   arg1 = (Dali::Toolkit::Slider *)jarg1;
75246   if (!arg1) {
75247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
75248     return 0;
75249   }
75250   {
75251     try {
75252       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
75253     } catch (std::out_of_range& e) {
75254       {
75255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75256       };
75257     } catch (std::exception& e) {
75258       {
75259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75260       };
75261     } catch (...) {
75262       {
75263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75264       };
75265     }
75266   }
75267   jresult = (void *)result;
75268   return jresult;
75269 }
75270
75271
75272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
75273   void * jresult ;
75274   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
75275   Dali::Toolkit::Slider *arg2 = 0 ;
75276   Dali::Toolkit::Slider *result = 0 ;
75277
75278   arg1 = (Dali::Toolkit::Slider *)jarg1;
75279   arg2 = (Dali::Toolkit::Slider *)jarg2;
75280   if (!arg2) {
75281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
75282     return 0;
75283   }
75284   {
75285     try {
75286       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
75287     } catch (std::out_of_range& e) {
75288       {
75289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75290       };
75291     } catch (std::exception& e) {
75292       {
75293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75294       };
75295     } catch (...) {
75296       {
75297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75298       };
75299     }
75300   }
75301   jresult = (void *)result;
75302   return jresult;
75303 }
75304
75305
75306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
75307   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
75308
75309   arg1 = (Dali::Toolkit::Slider *)jarg1;
75310   {
75311     try {
75312       delete arg1;
75313     } catch (std::out_of_range& e) {
75314       {
75315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75316       };
75317     } catch (std::exception& e) {
75318       {
75319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75320       };
75321     } catch (...) {
75322       {
75323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75324       };
75325     }
75326   }
75327 }
75328
75329
75330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
75331   void * jresult ;
75332   Dali::BaseHandle arg1 ;
75333   Dali::BaseHandle *argp1 ;
75334   Dali::Toolkit::Slider result;
75335
75336   argp1 = (Dali::BaseHandle *)jarg1;
75337   if (!argp1) {
75338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
75339     return 0;
75340   }
75341   arg1 = *argp1;
75342   {
75343     try {
75344       result = Dali::Toolkit::Slider::DownCast(arg1);
75345     } catch (std::out_of_range& e) {
75346       {
75347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75348       };
75349     } catch (std::exception& e) {
75350       {
75351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75352       };
75353     } catch (...) {
75354       {
75355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75356       };
75357     }
75358   }
75359   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
75360   return jresult;
75361 }
75362
75363
75364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
75365   void * jresult ;
75366   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
75367   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
75368
75369   arg1 = (Dali::Toolkit::Slider *)jarg1;
75370   {
75371     try {
75372       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
75373     } catch (std::out_of_range& e) {
75374       {
75375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75376       };
75377     } catch (std::exception& e) {
75378       {
75379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75380       };
75381     } catch (...) {
75382       {
75383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75384       };
75385     }
75386   }
75387   jresult = (void *)result;
75388   return jresult;
75389 }
75390
75391
75392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
75393   void * jresult ;
75394   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
75395   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
75396
75397   arg1 = (Dali::Toolkit::Slider *)jarg1;
75398   {
75399     try {
75400       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
75401     } catch (std::out_of_range& e) {
75402       {
75403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75404       };
75405     } catch (std::exception& e) {
75406       {
75407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75408       };
75409     } catch (...) {
75410       {
75411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75412       };
75413     }
75414   }
75415   jresult = (void *)result;
75416   return jresult;
75417 }
75418
75419
75420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
75421   void * jresult ;
75422   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
75423   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
75424
75425   arg1 = (Dali::Toolkit::Slider *)jarg1;
75426   {
75427     try {
75428       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
75429     } catch (std::out_of_range& e) {
75430       {
75431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75432       };
75433     } catch (std::exception& e) {
75434       {
75435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75436       };
75437     } catch (...) {
75438       {
75439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75440       };
75441     }
75442   }
75443   jresult = (void *)result;
75444   return jresult;
75445 }
75446
75447
75448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
75449   int jresult ;
75450   int result;
75451
75452   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
75453   jresult = (int)result;
75454   return jresult;
75455 }
75456
75457
75458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
75459   int jresult ;
75460   int result;
75461
75462   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
75463   jresult = (int)result;
75464   return jresult;
75465 }
75466
75467
75468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
75469   int jresult ;
75470   int result;
75471
75472   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
75473   jresult = (int)result;
75474   return jresult;
75475 }
75476
75477
75478 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
75479   int jresult ;
75480   int result;
75481
75482   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
75483   jresult = (int)result;
75484   return jresult;
75485 }
75486
75487
75488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
75489   void * jresult ;
75490   Dali::Toolkit::VideoView::Property *result = 0 ;
75491
75492   {
75493     try {
75494       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
75495     } catch (std::out_of_range& e) {
75496       {
75497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75498       };
75499     } catch (std::exception& e) {
75500       {
75501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75502       };
75503     } catch (...) {
75504       {
75505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75506       };
75507     }
75508   }
75509   jresult = (void *)result;
75510   return jresult;
75511 }
75512
75513
75514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
75515   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
75516
75517   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
75518   {
75519     try {
75520       delete arg1;
75521     } catch (std::out_of_range& e) {
75522       {
75523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75524       };
75525     } catch (std::exception& e) {
75526       {
75527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75528       };
75529     } catch (...) {
75530       {
75531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75532       };
75533     }
75534   }
75535 }
75536
75537
75538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
75539   void * jresult ;
75540   Dali::Toolkit::VideoView result;
75541
75542   {
75543     try {
75544       result = Dali::Toolkit::VideoView::New();
75545     } catch (std::out_of_range& e) {
75546       {
75547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75548       };
75549     } catch (std::exception& e) {
75550       {
75551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75552       };
75553     } catch (...) {
75554       {
75555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75556       };
75557     }
75558   }
75559   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
75560   return jresult;
75561 }
75562
75563
75564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
75565   void * jresult ;
75566   std::string *arg1 = 0 ;
75567   Dali::Toolkit::VideoView result;
75568
75569   if (!jarg1) {
75570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
75571     return 0;
75572   }
75573   std::string arg1_str(jarg1);
75574   arg1 = &arg1_str;
75575   {
75576     try {
75577       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
75578     } catch (std::out_of_range& e) {
75579       {
75580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75581       };
75582     } catch (std::exception& e) {
75583       {
75584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75585       };
75586     } catch (...) {
75587       {
75588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75589       };
75590     }
75591   }
75592   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
75593
75594   //argout typemap for const std::string&
75595
75596   return jresult;
75597 }
75598
75599
75600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
75601   void * jresult ;
75602   Dali::Toolkit::VideoView *result = 0 ;
75603
75604   {
75605     try {
75606       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
75607     } catch (std::out_of_range& e) {
75608       {
75609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75610       };
75611     } catch (std::exception& e) {
75612       {
75613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75614       };
75615     } catch (...) {
75616       {
75617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75618       };
75619     }
75620   }
75621   jresult = (void *)result;
75622   return jresult;
75623 }
75624
75625
75626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
75627   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75628
75629   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75630   {
75631     try {
75632       delete arg1;
75633     } catch (std::out_of_range& e) {
75634       {
75635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75636       };
75637     } catch (std::exception& e) {
75638       {
75639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75640       };
75641     } catch (...) {
75642       {
75643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75644       };
75645     }
75646   }
75647 }
75648
75649
75650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
75651   void * jresult ;
75652   Dali::Toolkit::VideoView *arg1 = 0 ;
75653   Dali::Toolkit::VideoView *result = 0 ;
75654
75655   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75656   if (!arg1) {
75657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
75658     return 0;
75659   }
75660   {
75661     try {
75662       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
75663     } catch (std::out_of_range& e) {
75664       {
75665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75666       };
75667     } catch (std::exception& e) {
75668       {
75669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75670       };
75671     } catch (...) {
75672       {
75673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75674       };
75675     }
75676   }
75677   jresult = (void *)result;
75678   return jresult;
75679 }
75680
75681
75682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
75683   void * jresult ;
75684   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75685   Dali::Toolkit::VideoView *arg2 = 0 ;
75686   Dali::Toolkit::VideoView *result = 0 ;
75687
75688   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75689   arg2 = (Dali::Toolkit::VideoView *)jarg2;
75690   if (!arg2) {
75691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
75692     return 0;
75693   }
75694   {
75695     try {
75696       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
75697     } catch (std::out_of_range& e) {
75698       {
75699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75700       };
75701     } catch (std::exception& e) {
75702       {
75703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75704       };
75705     } catch (...) {
75706       {
75707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75708       };
75709     }
75710   }
75711   jresult = (void *)result;
75712   return jresult;
75713 }
75714
75715
75716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
75717   void * jresult ;
75718   Dali::BaseHandle arg1 ;
75719   Dali::BaseHandle *argp1 ;
75720   Dali::Toolkit::VideoView result;
75721
75722   argp1 = (Dali::BaseHandle *)jarg1;
75723   if (!argp1) {
75724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
75725     return 0;
75726   }
75727   arg1 = *argp1;
75728   {
75729     try {
75730       result = Dali::Toolkit::VideoView::DownCast(arg1);
75731     } catch (std::out_of_range& e) {
75732       {
75733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75734       };
75735     } catch (std::exception& e) {
75736       {
75737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75738       };
75739     } catch (...) {
75740       {
75741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75742       };
75743     }
75744   }
75745   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
75746   return jresult;
75747 }
75748
75749
75750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
75751   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75752
75753   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75754   {
75755     try {
75756       (arg1)->Play();
75757     } catch (std::out_of_range& e) {
75758       {
75759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75760       };
75761     } catch (std::exception& e) {
75762       {
75763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75764       };
75765     } catch (...) {
75766       {
75767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75768       };
75769     }
75770   }
75771 }
75772
75773
75774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
75775   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75776
75777   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75778   {
75779     try {
75780       (arg1)->Pause();
75781     } catch (std::out_of_range& e) {
75782       {
75783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75784       };
75785     } catch (std::exception& e) {
75786       {
75787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75788       };
75789     } catch (...) {
75790       {
75791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75792       };
75793     }
75794   }
75795 }
75796
75797
75798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
75799   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75800
75801   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75802   {
75803     try {
75804       (arg1)->Stop();
75805     } catch (std::out_of_range& e) {
75806       {
75807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75808       };
75809     } catch (std::exception& e) {
75810       {
75811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75812       };
75813     } catch (...) {
75814       {
75815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75816       };
75817     }
75818   }
75819 }
75820
75821
75822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
75823   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75824   int arg2 ;
75825
75826   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75827   arg2 = (int)jarg2;
75828   {
75829     try {
75830       (arg1)->Forward(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_VideoView_Backward(void * jarg1, int jarg2) {
75849   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75850   int arg2 ;
75851
75852   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75853   arg2 = (int)jarg2;
75854   {
75855     try {
75856       (arg1)->Backward(arg2);
75857     } catch (std::out_of_range& e) {
75858       {
75859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75860       };
75861     } catch (std::exception& e) {
75862       {
75863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75864       };
75865     } catch (...) {
75866       {
75867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75868       };
75869     }
75870   }
75871 }
75872
75873
75874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
75875   void * jresult ;
75876   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75877   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
75878
75879   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75880   {
75881     try {
75882       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
75883     } catch (std::out_of_range& e) {
75884       {
75885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75886       };
75887     } catch (std::exception& e) {
75888       {
75889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75890       };
75891     } catch (...) {
75892       {
75893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75894       };
75895     }
75896   }
75897   jresult = (void *)result;
75898   return jresult;
75899 }
75900
75901
75902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
75903   int jresult ;
75904   int result;
75905
75906   result = (int)Dali::Toolkit::Popup::Property::TITLE;
75907   jresult = (int)result;
75908   return jresult;
75909 }
75910
75911
75912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
75913   int jresult ;
75914   int result;
75915
75916   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
75917   jresult = (int)result;
75918   return jresult;
75919 }
75920
75921
75922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
75923   int jresult ;
75924   int result;
75925
75926   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
75927   jresult = (int)result;
75928   return jresult;
75929 }
75930
75931
75932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
75933   int jresult ;
75934   int result;
75935
75936   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
75937   jresult = (int)result;
75938   return jresult;
75939 }
75940
75941
75942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
75943   int jresult ;
75944   int result;
75945
75946   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
75947   jresult = (int)result;
75948   return jresult;
75949 }
75950
75951
75952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
75953   int jresult ;
75954   int result;
75955
75956   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
75957   jresult = (int)result;
75958   return jresult;
75959 }
75960
75961
75962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
75963   int jresult ;
75964   int result;
75965
75966   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
75967   jresult = (int)result;
75968   return jresult;
75969 }
75970
75971
75972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
75973   int jresult ;
75974   int result;
75975
75976   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
75977   jresult = (int)result;
75978   return jresult;
75979 }
75980
75981
75982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
75983   int jresult ;
75984   int result;
75985
75986   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
75987   jresult = (int)result;
75988   return jresult;
75989 }
75990
75991
75992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
75993   int jresult ;
75994   int result;
75995
75996   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
75997   jresult = (int)result;
75998   return jresult;
75999 }
76000
76001
76002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
76003   int jresult ;
76004   int result;
76005
76006   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
76007   jresult = (int)result;
76008   return jresult;
76009 }
76010
76011
76012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
76013   int jresult ;
76014   int result;
76015
76016   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
76017   jresult = (int)result;
76018   return jresult;
76019 }
76020
76021
76022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
76023   int jresult ;
76024   int result;
76025
76026   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
76027   jresult = (int)result;
76028   return jresult;
76029 }
76030
76031
76032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
76033   int jresult ;
76034   int result;
76035
76036   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
76037   jresult = (int)result;
76038   return jresult;
76039 }
76040
76041
76042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
76043   int jresult ;
76044   int result;
76045
76046   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
76047   jresult = (int)result;
76048   return jresult;
76049 }
76050
76051
76052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
76053   int jresult ;
76054   int result;
76055
76056   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
76057   jresult = (int)result;
76058   return jresult;
76059 }
76060
76061
76062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
76063   int jresult ;
76064   int result;
76065
76066   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
76067   jresult = (int)result;
76068   return jresult;
76069 }
76070
76071
76072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
76073   int jresult ;
76074   int result;
76075
76076   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
76077   jresult = (int)result;
76078   return jresult;
76079 }
76080
76081
76082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
76083   int jresult ;
76084   int result;
76085
76086   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
76087   jresult = (int)result;
76088   return jresult;
76089 }
76090
76091
76092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
76093   int jresult ;
76094   int result;
76095
76096   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
76097   jresult = (int)result;
76098   return jresult;
76099 }
76100
76101
76102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
76103   int jresult ;
76104   int result;
76105
76106   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
76107   jresult = (int)result;
76108   return jresult;
76109 }
76110
76111
76112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
76113   void * jresult ;
76114   Dali::Toolkit::Popup::Property *result = 0 ;
76115
76116   {
76117     try {
76118       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
76119     } catch (std::out_of_range& e) {
76120       {
76121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76122       };
76123     } catch (std::exception& e) {
76124       {
76125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76126       };
76127     } catch (...) {
76128       {
76129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76130       };
76131     }
76132   }
76133   jresult = (void *)result;
76134   return jresult;
76135 }
76136
76137
76138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
76139   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
76140
76141   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
76142   {
76143     try {
76144       delete arg1;
76145     } catch (std::out_of_range& e) {
76146       {
76147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76148       };
76149     } catch (std::exception& e) {
76150       {
76151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76152       };
76153     } catch (...) {
76154       {
76155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76156       };
76157     }
76158   }
76159 }
76160
76161
76162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
76163   void * jresult ;
76164   Dali::Toolkit::Popup *result = 0 ;
76165
76166   {
76167     try {
76168       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
76169     } catch (std::out_of_range& e) {
76170       {
76171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76172       };
76173     } catch (std::exception& e) {
76174       {
76175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76176       };
76177     } catch (...) {
76178       {
76179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76180       };
76181     }
76182   }
76183   jresult = (void *)result;
76184   return jresult;
76185 }
76186
76187
76188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
76189   void * jresult ;
76190   Dali::Toolkit::Popup result;
76191
76192   {
76193     try {
76194       result = Dali::Toolkit::Popup::New();
76195     } catch (std::out_of_range& e) {
76196       {
76197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76198       };
76199     } catch (std::exception& e) {
76200       {
76201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76202       };
76203     } catch (...) {
76204       {
76205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76206       };
76207     }
76208   }
76209   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
76210   return jresult;
76211 }
76212
76213
76214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
76215   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76216
76217   arg1 = (Dali::Toolkit::Popup *)jarg1;
76218   {
76219     try {
76220       delete arg1;
76221     } catch (std::out_of_range& e) {
76222       {
76223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76224       };
76225     } catch (std::exception& e) {
76226       {
76227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76228       };
76229     } catch (...) {
76230       {
76231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76232       };
76233     }
76234   }
76235 }
76236
76237
76238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
76239   void * jresult ;
76240   Dali::Toolkit::Popup *arg1 = 0 ;
76241   Dali::Toolkit::Popup *result = 0 ;
76242
76243   arg1 = (Dali::Toolkit::Popup *)jarg1;
76244   if (!arg1) {
76245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
76246     return 0;
76247   }
76248   {
76249     try {
76250       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
76251     } catch (std::out_of_range& e) {
76252       {
76253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76254       };
76255     } catch (std::exception& e) {
76256       {
76257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76258       };
76259     } catch (...) {
76260       {
76261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76262       };
76263     }
76264   }
76265   jresult = (void *)result;
76266   return jresult;
76267 }
76268
76269
76270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
76271   void * jresult ;
76272   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76273   Dali::Toolkit::Popup *arg2 = 0 ;
76274   Dali::Toolkit::Popup *result = 0 ;
76275
76276   arg1 = (Dali::Toolkit::Popup *)jarg1;
76277   arg2 = (Dali::Toolkit::Popup *)jarg2;
76278   if (!arg2) {
76279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
76280     return 0;
76281   }
76282   {
76283     try {
76284       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
76285     } catch (std::out_of_range& e) {
76286       {
76287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76288       };
76289     } catch (std::exception& e) {
76290       {
76291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76292       };
76293     } catch (...) {
76294       {
76295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76296       };
76297     }
76298   }
76299   jresult = (void *)result;
76300   return jresult;
76301 }
76302
76303
76304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
76305   void * jresult ;
76306   Dali::BaseHandle arg1 ;
76307   Dali::BaseHandle *argp1 ;
76308   Dali::Toolkit::Popup result;
76309
76310   argp1 = (Dali::BaseHandle *)jarg1;
76311   if (!argp1) {
76312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76313     return 0;
76314   }
76315   arg1 = *argp1;
76316   {
76317     try {
76318       result = Dali::Toolkit::Popup::DownCast(arg1);
76319     } catch (std::out_of_range& e) {
76320       {
76321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76322       };
76323     } catch (std::exception& e) {
76324       {
76325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76326       };
76327     } catch (...) {
76328       {
76329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76330       };
76331     }
76332   }
76333   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
76334   return jresult;
76335 }
76336
76337
76338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
76339   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76340   Dali::Actor arg2 ;
76341   Dali::Actor *argp2 ;
76342
76343   arg1 = (Dali::Toolkit::Popup *)jarg1;
76344   argp2 = (Dali::Actor *)jarg2;
76345   if (!argp2) {
76346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76347     return ;
76348   }
76349   arg2 = *argp2;
76350   {
76351     try {
76352       (arg1)->SetTitle(arg2);
76353     } catch (std::out_of_range& e) {
76354       {
76355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76356       };
76357     } catch (std::exception& e) {
76358       {
76359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76360       };
76361     } catch (...) {
76362       {
76363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76364       };
76365     }
76366   }
76367 }
76368
76369
76370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
76371   void * jresult ;
76372   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76373   Dali::Actor result;
76374
76375   arg1 = (Dali::Toolkit::Popup *)jarg1;
76376   {
76377     try {
76378       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
76379     } catch (std::out_of_range& e) {
76380       {
76381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76382       };
76383     } catch (std::exception& e) {
76384       {
76385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76386       };
76387     } catch (...) {
76388       {
76389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76390       };
76391     }
76392   }
76393   jresult = new Dali::Actor((const Dali::Actor &)result);
76394   return jresult;
76395 }
76396
76397
76398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
76399   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76400   Dali::Actor arg2 ;
76401   Dali::Actor *argp2 ;
76402
76403   arg1 = (Dali::Toolkit::Popup *)jarg1;
76404   argp2 = (Dali::Actor *)jarg2;
76405   if (!argp2) {
76406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76407     return ;
76408   }
76409   arg2 = *argp2;
76410   {
76411     try {
76412       (arg1)->SetContent(arg2);
76413     } catch (std::out_of_range& e) {
76414       {
76415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76416       };
76417     } catch (std::exception& e) {
76418       {
76419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76420       };
76421     } catch (...) {
76422       {
76423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76424       };
76425     }
76426   }
76427 }
76428
76429
76430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
76431   void * jresult ;
76432   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76433   Dali::Actor result;
76434
76435   arg1 = (Dali::Toolkit::Popup *)jarg1;
76436   {
76437     try {
76438       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
76439     } catch (std::out_of_range& e) {
76440       {
76441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76442       };
76443     } catch (std::exception& e) {
76444       {
76445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76446       };
76447     } catch (...) {
76448       {
76449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76450       };
76451     }
76452   }
76453   jresult = new Dali::Actor((const Dali::Actor &)result);
76454   return jresult;
76455 }
76456
76457
76458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
76459   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76460   Dali::Actor arg2 ;
76461   Dali::Actor *argp2 ;
76462
76463   arg1 = (Dali::Toolkit::Popup *)jarg1;
76464   argp2 = (Dali::Actor *)jarg2;
76465   if (!argp2) {
76466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76467     return ;
76468   }
76469   arg2 = *argp2;
76470   {
76471     try {
76472       (arg1)->SetFooter(arg2);
76473     } catch (std::out_of_range& e) {
76474       {
76475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76476       };
76477     } catch (std::exception& e) {
76478       {
76479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76480       };
76481     } catch (...) {
76482       {
76483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76484       };
76485     }
76486   }
76487 }
76488
76489
76490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
76491   void * jresult ;
76492   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76493   Dali::Actor result;
76494
76495   arg1 = (Dali::Toolkit::Popup *)jarg1;
76496   {
76497     try {
76498       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
76499     } catch (std::out_of_range& e) {
76500       {
76501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76502       };
76503     } catch (std::exception& e) {
76504       {
76505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76506       };
76507     } catch (...) {
76508       {
76509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76510       };
76511     }
76512   }
76513   jresult = new Dali::Actor((const Dali::Actor &)result);
76514   return jresult;
76515 }
76516
76517
76518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
76519   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76520   Dali::Toolkit::Popup::DisplayState arg2 ;
76521
76522   arg1 = (Dali::Toolkit::Popup *)jarg1;
76523   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
76524   {
76525     try {
76526       (arg1)->SetDisplayState(arg2);
76527     } catch (std::out_of_range& e) {
76528       {
76529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76530       };
76531     } catch (std::exception& e) {
76532       {
76533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76534       };
76535     } catch (...) {
76536       {
76537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76538       };
76539     }
76540   }
76541 }
76542
76543
76544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
76545   int jresult ;
76546   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76547   Dali::Toolkit::Popup::DisplayState result;
76548
76549   arg1 = (Dali::Toolkit::Popup *)jarg1;
76550   {
76551     try {
76552       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
76553     } catch (std::out_of_range& e) {
76554       {
76555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76556       };
76557     } catch (std::exception& e) {
76558       {
76559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76560       };
76561     } catch (...) {
76562       {
76563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76564       };
76565     }
76566   }
76567   jresult = (int)result;
76568   return jresult;
76569 }
76570
76571
76572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
76573   void * jresult ;
76574   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76575   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
76576
76577   arg1 = (Dali::Toolkit::Popup *)jarg1;
76578   {
76579     try {
76580       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
76581     } catch (std::out_of_range& e) {
76582       {
76583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76584       };
76585     } catch (std::exception& e) {
76586       {
76587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76588       };
76589     } catch (...) {
76590       {
76591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76592       };
76593     }
76594   }
76595   jresult = (void *)result;
76596   return jresult;
76597 }
76598
76599
76600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
76601   void * jresult ;
76602   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76603   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
76604
76605   arg1 = (Dali::Toolkit::Popup *)jarg1;
76606   {
76607     try {
76608       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
76609     } catch (std::out_of_range& e) {
76610       {
76611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76612       };
76613     } catch (std::exception& e) {
76614       {
76615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76616       };
76617     } catch (...) {
76618       {
76619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76620       };
76621     }
76622   }
76623   jresult = (void *)result;
76624   return jresult;
76625 }
76626
76627
76628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
76629   void * jresult ;
76630   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76631   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
76632
76633   arg1 = (Dali::Toolkit::Popup *)jarg1;
76634   {
76635     try {
76636       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
76637     } catch (std::out_of_range& e) {
76638       {
76639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76640       };
76641     } catch (std::exception& e) {
76642       {
76643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76644       };
76645     } catch (...) {
76646       {
76647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76648       };
76649     }
76650   }
76651   jresult = (void *)result;
76652   return jresult;
76653 }
76654
76655
76656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
76657   void * jresult ;
76658   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76659   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
76660
76661   arg1 = (Dali::Toolkit::Popup *)jarg1;
76662   {
76663     try {
76664       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
76665     } catch (std::out_of_range& e) {
76666       {
76667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76668       };
76669     } catch (std::exception& e) {
76670       {
76671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76672       };
76673     } catch (...) {
76674       {
76675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76676       };
76677     }
76678   }
76679   jresult = (void *)result;
76680   return jresult;
76681 }
76682
76683
76684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
76685   void * jresult ;
76686   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76687   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
76688
76689   arg1 = (Dali::Toolkit::Popup *)jarg1;
76690   {
76691     try {
76692       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
76693     } catch (std::out_of_range& e) {
76694       {
76695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76696       };
76697     } catch (std::exception& e) {
76698       {
76699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76700       };
76701     } catch (...) {
76702       {
76703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76704       };
76705     }
76706   }
76707   jresult = (void *)result;
76708   return jresult;
76709 }
76710
76711
76712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
76713   int jresult ;
76714   int result;
76715
76716   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
76717   jresult = (int)result;
76718   return jresult;
76719 }
76720
76721
76722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
76723   int jresult ;
76724   int result;
76725
76726   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
76727   jresult = (int)result;
76728   return jresult;
76729 }
76730
76731
76732 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
76733   int jresult ;
76734   int result;
76735
76736   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
76737   jresult = (int)result;
76738   return jresult;
76739 }
76740
76741
76742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
76743   int jresult ;
76744   int result;
76745
76746   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
76747   jresult = (int)result;
76748   return jresult;
76749 }
76750
76751
76752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
76753   int jresult ;
76754   int result;
76755
76756   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
76757   jresult = (int)result;
76758   return jresult;
76759 }
76760
76761
76762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
76763   int jresult ;
76764   int result;
76765
76766   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
76767   jresult = (int)result;
76768   return jresult;
76769 }
76770
76771
76772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
76773   int jresult ;
76774   int result;
76775
76776   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
76777   jresult = (int)result;
76778   return jresult;
76779 }
76780
76781
76782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
76783   int jresult ;
76784   int result;
76785
76786   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
76787   jresult = (int)result;
76788   return jresult;
76789 }
76790
76791
76792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
76793   int jresult ;
76794   int result;
76795
76796   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
76797   jresult = (int)result;
76798   return jresult;
76799 }
76800
76801
76802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
76803   void * jresult ;
76804   Dali::Toolkit::ProgressBar::Property *result = 0 ;
76805
76806   {
76807     try {
76808       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
76809     } catch (std::out_of_range& e) {
76810       {
76811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76812       };
76813     } catch (std::exception& e) {
76814       {
76815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76816       };
76817     } catch (...) {
76818       {
76819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76820       };
76821     }
76822   }
76823   jresult = (void *)result;
76824   return jresult;
76825 }
76826
76827
76828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
76829   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
76830
76831   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
76832   {
76833     try {
76834       delete arg1;
76835     } catch (std::out_of_range& e) {
76836       {
76837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76838       };
76839     } catch (std::exception& e) {
76840       {
76841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76842       };
76843     } catch (...) {
76844       {
76845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76846       };
76847     }
76848   }
76849 }
76850
76851
76852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
76853   void * jresult ;
76854   Dali::Toolkit::ProgressBar result;
76855
76856   {
76857     try {
76858       result = Dali::Toolkit::ProgressBar::New();
76859     } catch (std::out_of_range& e) {
76860       {
76861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76862       };
76863     } catch (std::exception& e) {
76864       {
76865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76866       };
76867     } catch (...) {
76868       {
76869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76870       };
76871     }
76872   }
76873   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
76874   return jresult;
76875 }
76876
76877
76878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
76879   void * jresult ;
76880   Dali::Toolkit::ProgressBar *result = 0 ;
76881
76882   {
76883     try {
76884       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
76885     } catch (std::out_of_range& e) {
76886       {
76887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76888       };
76889     } catch (std::exception& e) {
76890       {
76891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76892       };
76893     } catch (...) {
76894       {
76895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76896       };
76897     }
76898   }
76899   jresult = (void *)result;
76900   return jresult;
76901 }
76902
76903
76904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
76905   void * jresult ;
76906   Dali::Toolkit::ProgressBar *arg1 = 0 ;
76907   Dali::Toolkit::ProgressBar *result = 0 ;
76908
76909   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
76910   if (!arg1) {
76911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
76912     return 0;
76913   }
76914   {
76915     try {
76916       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
76917     } catch (std::out_of_range& e) {
76918       {
76919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76920       };
76921     } catch (std::exception& e) {
76922       {
76923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76924       };
76925     } catch (...) {
76926       {
76927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76928       };
76929     }
76930   }
76931   jresult = (void *)result;
76932   return jresult;
76933 }
76934
76935
76936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
76937   void * jresult ;
76938   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
76939   Dali::Toolkit::ProgressBar *arg2 = 0 ;
76940   Dali::Toolkit::ProgressBar *result = 0 ;
76941
76942   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
76943   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
76944   if (!arg2) {
76945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
76946     return 0;
76947   }
76948   {
76949     try {
76950       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
76951     } catch (std::out_of_range& e) {
76952       {
76953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76954       };
76955     } catch (std::exception& e) {
76956       {
76957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76958       };
76959     } catch (...) {
76960       {
76961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76962       };
76963     }
76964   }
76965   jresult = (void *)result;
76966   return jresult;
76967 }
76968
76969
76970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
76971   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
76972
76973   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
76974   {
76975     try {
76976       delete arg1;
76977     } catch (std::out_of_range& e) {
76978       {
76979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76980       };
76981     } catch (std::exception& e) {
76982       {
76983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76984       };
76985     } catch (...) {
76986       {
76987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76988       };
76989     }
76990   }
76991 }
76992
76993
76994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
76995   void * jresult ;
76996   Dali::BaseHandle arg1 ;
76997   Dali::BaseHandle *argp1 ;
76998   Dali::Toolkit::ProgressBar result;
76999
77000   argp1 = (Dali::BaseHandle *)jarg1;
77001   if (!argp1) {
77002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77003     return 0;
77004   }
77005   arg1 = *argp1;
77006   {
77007     try {
77008       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
77009     } catch (std::out_of_range& e) {
77010       {
77011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77012       };
77013     } catch (std::exception& e) {
77014       {
77015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77016       };
77017     } catch (...) {
77018       {
77019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77020       };
77021     }
77022   }
77023   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
77024   return jresult;
77025 }
77026
77027
77028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
77029   void * jresult ;
77030   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
77031   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
77032
77033   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
77034   {
77035     try {
77036       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
77037     } catch (std::out_of_range& e) {
77038       {
77039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77040       };
77041     } catch (std::exception& e) {
77042       {
77043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77044       };
77045     } catch (...) {
77046       {
77047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77048       };
77049     }
77050   }
77051   jresult = (void *)result;
77052   return jresult;
77053 }
77054
77055
77056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
77057   void * jresult ;
77058   Dali::Toolkit::GaussianBlurView *result = 0 ;
77059
77060   {
77061     try {
77062       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
77063     } catch (std::out_of_range& e) {
77064       {
77065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77066       };
77067     } catch (std::exception& e) {
77068       {
77069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77070       };
77071     } catch (...) {
77072       {
77073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77074       };
77075     }
77076   }
77077   jresult = (void *)result;
77078   return jresult;
77079 }
77080
77081
77082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
77083   void * jresult ;
77084   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
77085   Dali::Toolkit::GaussianBlurView *result = 0 ;
77086
77087   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77088   if (!arg1) {
77089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
77090     return 0;
77091   }
77092   {
77093     try {
77094       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
77095     } catch (std::out_of_range& e) {
77096       {
77097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77098       };
77099     } catch (std::exception& e) {
77100       {
77101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77102       };
77103     } catch (...) {
77104       {
77105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77106       };
77107     }
77108   }
77109   jresult = (void *)result;
77110   return jresult;
77111 }
77112
77113
77114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
77115   void * jresult ;
77116   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77117   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
77118   Dali::Toolkit::GaussianBlurView *result = 0 ;
77119
77120   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77121   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
77122   if (!arg2) {
77123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
77124     return 0;
77125   }
77126   {
77127     try {
77128       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
77129     } catch (std::out_of_range& e) {
77130       {
77131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77132       };
77133     } catch (std::exception& e) {
77134       {
77135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77136       };
77137     } catch (...) {
77138       {
77139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77140       };
77141     }
77142   }
77143   jresult = (void *)result;
77144   return jresult;
77145 }
77146
77147
77148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
77149   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77150
77151   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77152   {
77153     try {
77154       delete arg1;
77155     } catch (std::out_of_range& e) {
77156       {
77157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77158       };
77159     } catch (std::exception& e) {
77160       {
77161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77162       };
77163     } catch (...) {
77164       {
77165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77166       };
77167     }
77168   }
77169 }
77170
77171
77172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
77173   void * jresult ;
77174   Dali::BaseHandle arg1 ;
77175   Dali::BaseHandle *argp1 ;
77176   Dali::Toolkit::GaussianBlurView result;
77177
77178   argp1 = (Dali::BaseHandle *)jarg1;
77179   if (!argp1) {
77180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77181     return 0;
77182   }
77183   arg1 = *argp1;
77184   {
77185     try {
77186       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
77187     } catch (std::out_of_range& e) {
77188       {
77189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77190       };
77191     } catch (std::exception& e) {
77192       {
77193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77194       };
77195     } catch (...) {
77196       {
77197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77198       };
77199     }
77200   }
77201   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
77202   return jresult;
77203 }
77204
77205
77206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
77207   void * jresult ;
77208   Dali::Toolkit::GaussianBlurView result;
77209
77210   {
77211     try {
77212       result = Dali::Toolkit::GaussianBlurView::New();
77213     } catch (std::out_of_range& e) {
77214       {
77215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77216       };
77217     } catch (std::exception& e) {
77218       {
77219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77220       };
77221     } catch (...) {
77222       {
77223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77224       };
77225     }
77226   }
77227   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
77228   return jresult;
77229 }
77230
77231
77232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
77233   void * jresult ;
77234   unsigned int arg1 ;
77235   float arg2 ;
77236   Dali::Pixel::Format arg3 ;
77237   float arg4 ;
77238   float arg5 ;
77239   bool arg6 ;
77240   Dali::Toolkit::GaussianBlurView result;
77241
77242   arg1 = (unsigned int)jarg1;
77243   arg2 = (float)jarg2;
77244   arg3 = (Dali::Pixel::Format)jarg3;
77245   arg4 = (float)jarg4;
77246   arg5 = (float)jarg5;
77247   arg6 = jarg6 ? true : false;
77248   {
77249     try {
77250       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
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 = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
77266   return jresult;
77267 }
77268
77269
77270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
77271   void * jresult ;
77272   unsigned int arg1 ;
77273   float arg2 ;
77274   Dali::Pixel::Format arg3 ;
77275   float arg4 ;
77276   float arg5 ;
77277   Dali::Toolkit::GaussianBlurView result;
77278
77279   arg1 = (unsigned int)jarg1;
77280   arg2 = (float)jarg2;
77281   arg3 = (Dali::Pixel::Format)jarg3;
77282   arg4 = (float)jarg4;
77283   arg5 = (float)jarg5;
77284   {
77285     try {
77286       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
77287     } catch (std::out_of_range& e) {
77288       {
77289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77290       };
77291     } catch (std::exception& e) {
77292       {
77293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77294       };
77295     } catch (...) {
77296       {
77297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77298       };
77299     }
77300   }
77301   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
77302   return jresult;
77303 }
77304
77305
77306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
77307   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77308   Dali::Actor arg2 ;
77309   Dali::Actor *argp2 ;
77310
77311   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77312   argp2 = (Dali::Actor *)jarg2;
77313   if (!argp2) {
77314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77315     return ;
77316   }
77317   arg2 = *argp2;
77318   {
77319     try {
77320       (arg1)->Add(arg2);
77321     } catch (std::out_of_range& e) {
77322       {
77323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77324       };
77325     } catch (std::exception& e) {
77326       {
77327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77328       };
77329     } catch (...) {
77330       {
77331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77332       };
77333     }
77334   }
77335 }
77336
77337
77338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
77339   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77340   Dali::Actor arg2 ;
77341   Dali::Actor *argp2 ;
77342
77343   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77344   argp2 = (Dali::Actor *)jarg2;
77345   if (!argp2) {
77346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77347     return ;
77348   }
77349   arg2 = *argp2;
77350   {
77351     try {
77352       (arg1)->Remove(arg2);
77353     } catch (std::out_of_range& e) {
77354       {
77355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77356       };
77357     } catch (std::exception& e) {
77358       {
77359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77360       };
77361     } catch (...) {
77362       {
77363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77364       };
77365     }
77366   }
77367 }
77368
77369
77370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
77371   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77372
77373   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77374   {
77375     try {
77376       (arg1)->Activate();
77377     } catch (std::out_of_range& e) {
77378       {
77379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77380       };
77381     } catch (std::exception& e) {
77382       {
77383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77384       };
77385     } catch (...) {
77386       {
77387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77388       };
77389     }
77390   }
77391 }
77392
77393
77394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
77395   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77396
77397   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77398   {
77399     try {
77400       (arg1)->ActivateOnce();
77401     } catch (std::out_of_range& e) {
77402       {
77403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77404       };
77405     } catch (std::exception& e) {
77406       {
77407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77408       };
77409     } catch (...) {
77410       {
77411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77412       };
77413     }
77414   }
77415 }
77416
77417
77418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
77419   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77420
77421   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77422   {
77423     try {
77424       (arg1)->Deactivate();
77425     } catch (std::out_of_range& e) {
77426       {
77427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77428       };
77429     } catch (std::exception& e) {
77430       {
77431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77432       };
77433     } catch (...) {
77434       {
77435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77436       };
77437     }
77438   }
77439 }
77440
77441
77442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
77443   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77444   Dali::Image arg2 ;
77445   Dali::FrameBufferImage arg3 ;
77446   Dali::Image *argp2 ;
77447   Dali::FrameBufferImage *argp3 ;
77448
77449   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77450   argp2 = (Dali::Image *)jarg2;
77451   if (!argp2) {
77452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
77453     return ;
77454   }
77455   arg2 = *argp2;
77456   argp3 = (Dali::FrameBufferImage *)jarg3;
77457   if (!argp3) {
77458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
77459     return ;
77460   }
77461   arg3 = *argp3;
77462   {
77463     try {
77464       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
77465     } catch (std::out_of_range& e) {
77466       {
77467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77468       };
77469     } catch (std::exception& e) {
77470       {
77471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77472       };
77473     } catch (...) {
77474       {
77475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77476       };
77477     }
77478   }
77479 }
77480
77481
77482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
77483   int jresult ;
77484   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77485   Dali::Property::Index result;
77486
77487   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77488   {
77489     try {
77490       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
77491     } catch (std::out_of_range& e) {
77492       {
77493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77494       };
77495     } catch (std::exception& e) {
77496       {
77497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77498       };
77499     } catch (...) {
77500       {
77501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77502       };
77503     }
77504   }
77505   jresult = result;
77506   return jresult;
77507 }
77508
77509
77510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
77511   void * jresult ;
77512   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77513   Dali::FrameBufferImage result;
77514
77515   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77516   {
77517     try {
77518       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
77519     } catch (std::out_of_range& e) {
77520       {
77521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77522       };
77523     } catch (std::exception& e) {
77524       {
77525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77526       };
77527     } catch (...) {
77528       {
77529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77530       };
77531     }
77532   }
77533   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
77534   return jresult;
77535 }
77536
77537
77538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
77539   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77540   Dali::Vector4 *arg2 = 0 ;
77541
77542   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77543   arg2 = (Dali::Vector4 *)jarg2;
77544   if (!arg2) {
77545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
77546     return ;
77547   }
77548   {
77549     try {
77550       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
77551     } catch (std::out_of_range& e) {
77552       {
77553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77554       };
77555     } catch (std::exception& e) {
77556       {
77557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77558       };
77559     } catch (...) {
77560       {
77561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77562       };
77563     }
77564   }
77565 }
77566
77567
77568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
77569   void * jresult ;
77570   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77571   Dali::Vector4 result;
77572
77573   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77574   {
77575     try {
77576       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
77577     } catch (std::out_of_range& e) {
77578       {
77579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77580       };
77581     } catch (std::exception& e) {
77582       {
77583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77584       };
77585     } catch (...) {
77586       {
77587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77588       };
77589     }
77590   }
77591   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
77592   return jresult;
77593 }
77594
77595
77596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
77597   void * jresult ;
77598   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77599   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
77600
77601   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77602   {
77603     try {
77604       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
77605     } catch (std::out_of_range& e) {
77606       {
77607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77608       };
77609     } catch (std::exception& e) {
77610       {
77611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77612       };
77613     } catch (...) {
77614       {
77615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77616       };
77617     }
77618   }
77619   jresult = (void *)result;
77620   return jresult;
77621 }
77622
77623
77624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
77625   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
77626
77627   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
77628   {
77629     try {
77630       delete arg1;
77631     } catch (std::out_of_range& e) {
77632       {
77633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77634       };
77635     } catch (std::exception& e) {
77636       {
77637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77638       };
77639     } catch (...) {
77640       {
77641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77642       };
77643     }
77644   }
77645 }
77646
77647
77648 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
77649   unsigned int jresult ;
77650   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
77651   unsigned int result;
77652
77653   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
77654   {
77655     try {
77656       result = (unsigned int)(arg1)->GetNumberOfPages();
77657     } catch (std::out_of_range& e) {
77658       {
77659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77660       };
77661     } catch (std::exception& e) {
77662       {
77663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77664       };
77665     } catch (...) {
77666       {
77667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77668       };
77669     }
77670   }
77671   jresult = result;
77672   return jresult;
77673 }
77674
77675
77676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
77677   void * jresult ;
77678   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
77679   unsigned int arg2 ;
77680   Dali::Texture result;
77681
77682   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
77683   arg2 = (unsigned int)jarg2;
77684   {
77685     try {
77686       result = (arg1)->NewPage(arg2);
77687     } catch (std::out_of_range& e) {
77688       {
77689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77690       };
77691     } catch (std::exception& e) {
77692       {
77693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77694       };
77695     } catch (...) {
77696       {
77697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77698       };
77699     }
77700   }
77701   jresult = new Dali::Texture((const Dali::Texture &)result);
77702   return jresult;
77703 }
77704
77705
77706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
77707   int jresult ;
77708   int result;
77709
77710   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
77711   jresult = (int)result;
77712   return jresult;
77713 }
77714
77715
77716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
77717   int jresult ;
77718   int result;
77719
77720   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
77721   jresult = (int)result;
77722   return jresult;
77723 }
77724
77725
77726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
77727   int jresult ;
77728   int result;
77729
77730   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
77731   jresult = (int)result;
77732   return jresult;
77733 }
77734
77735
77736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
77737   void * jresult ;
77738   Dali::Toolkit::PageTurnView::Property *result = 0 ;
77739
77740   {
77741     try {
77742       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
77743     } catch (std::out_of_range& e) {
77744       {
77745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77746       };
77747     } catch (std::exception& e) {
77748       {
77749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77750       };
77751     } catch (...) {
77752       {
77753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77754       };
77755     }
77756   }
77757   jresult = (void *)result;
77758   return jresult;
77759 }
77760
77761
77762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
77763   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
77764
77765   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
77766   {
77767     try {
77768       delete arg1;
77769     } catch (std::out_of_range& e) {
77770       {
77771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77772       };
77773     } catch (std::exception& e) {
77774       {
77775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77776       };
77777     } catch (...) {
77778       {
77779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77780       };
77781     }
77782   }
77783 }
77784
77785
77786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
77787   void * jresult ;
77788   Dali::Toolkit::PageTurnView *result = 0 ;
77789
77790   {
77791     try {
77792       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
77793     } catch (std::out_of_range& e) {
77794       {
77795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77796       };
77797     } catch (std::exception& e) {
77798       {
77799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77800       };
77801     } catch (...) {
77802       {
77803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77804       };
77805     }
77806   }
77807   jresult = (void *)result;
77808   return jresult;
77809 }
77810
77811
77812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
77813   void * jresult ;
77814   Dali::Toolkit::PageTurnView *arg1 = 0 ;
77815   Dali::Toolkit::PageTurnView *result = 0 ;
77816
77817   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
77818   if (!arg1) {
77819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
77820     return 0;
77821   }
77822   {
77823     try {
77824       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
77825     } catch (std::out_of_range& e) {
77826       {
77827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77828       };
77829     } catch (std::exception& e) {
77830       {
77831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77832       };
77833     } catch (...) {
77834       {
77835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77836       };
77837     }
77838   }
77839   jresult = (void *)result;
77840   return jresult;
77841 }
77842
77843
77844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
77845   void * jresult ;
77846   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
77847   Dali::Toolkit::PageTurnView *arg2 = 0 ;
77848   Dali::Toolkit::PageTurnView *result = 0 ;
77849
77850   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
77851   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
77852   if (!arg2) {
77853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
77854     return 0;
77855   }
77856   {
77857     try {
77858       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
77859     } catch (std::out_of_range& e) {
77860       {
77861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77862       };
77863     } catch (std::exception& e) {
77864       {
77865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77866       };
77867     } catch (...) {
77868       {
77869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77870       };
77871     }
77872   }
77873   jresult = (void *)result;
77874   return jresult;
77875 }
77876
77877
77878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
77879   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
77880
77881   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
77882   {
77883     try {
77884       delete arg1;
77885     } catch (std::out_of_range& e) {
77886       {
77887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77888       };
77889     } catch (std::exception& e) {
77890       {
77891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77892       };
77893     } catch (...) {
77894       {
77895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77896       };
77897     }
77898   }
77899 }
77900
77901
77902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
77903   void * jresult ;
77904   Dali::BaseHandle arg1 ;
77905   Dali::BaseHandle *argp1 ;
77906   Dali::Toolkit::PageTurnView result;
77907
77908   argp1 = (Dali::BaseHandle *)jarg1;
77909   if (!argp1) {
77910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77911     return 0;
77912   }
77913   arg1 = *argp1;
77914   {
77915     try {
77916       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
77917     } catch (std::out_of_range& e) {
77918       {
77919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77920       };
77921     } catch (std::exception& e) {
77922       {
77923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77924       };
77925     } catch (...) {
77926       {
77927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77928       };
77929     }
77930   }
77931   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
77932   return jresult;
77933 }
77934
77935
77936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
77937   void * jresult ;
77938   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
77939   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
77940
77941   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
77942   {
77943     try {
77944       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
77945     } catch (std::out_of_range& e) {
77946       {
77947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77948       };
77949     } catch (std::exception& e) {
77950       {
77951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77952       };
77953     } catch (...) {
77954       {
77955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77956       };
77957     }
77958   }
77959   jresult = (void *)result;
77960   return jresult;
77961 }
77962
77963
77964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
77965   void * jresult ;
77966   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
77967   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
77968
77969   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
77970   {
77971     try {
77972       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
77973     } catch (std::out_of_range& e) {
77974       {
77975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77976       };
77977     } catch (std::exception& e) {
77978       {
77979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77980       };
77981     } catch (...) {
77982       {
77983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77984       };
77985     }
77986   }
77987   jresult = (void *)result;
77988   return jresult;
77989 }
77990
77991
77992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
77993   void * jresult ;
77994   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
77995   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
77996
77997   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
77998   {
77999     try {
78000       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
78001     } catch (std::out_of_range& e) {
78002       {
78003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78004       };
78005     } catch (std::exception& e) {
78006       {
78007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78008       };
78009     } catch (...) {
78010       {
78011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78012       };
78013     }
78014   }
78015   jresult = (void *)result;
78016   return jresult;
78017 }
78018
78019
78020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
78021   void * jresult ;
78022   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
78023   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
78024
78025   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
78026   {
78027     try {
78028       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
78029     } catch (std::out_of_range& e) {
78030       {
78031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78032       };
78033     } catch (std::exception& e) {
78034       {
78035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78036       };
78037     } catch (...) {
78038       {
78039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78040       };
78041     }
78042   }
78043   jresult = (void *)result;
78044   return jresult;
78045 }
78046
78047
78048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
78049   void * jresult ;
78050   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
78051
78052   {
78053     try {
78054       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
78055     } catch (std::out_of_range& e) {
78056       {
78057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78058       };
78059     } catch (std::exception& e) {
78060       {
78061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78062       };
78063     } catch (...) {
78064       {
78065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78066       };
78067     }
78068   }
78069   jresult = (void *)result;
78070   return jresult;
78071 }
78072
78073
78074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
78075   void * jresult ;
78076   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
78077   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
78078
78079   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
78080   if (!arg1) {
78081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
78082     return 0;
78083   }
78084   {
78085     try {
78086       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
78087     } catch (std::out_of_range& e) {
78088       {
78089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78090       };
78091     } catch (std::exception& e) {
78092       {
78093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78094       };
78095     } catch (...) {
78096       {
78097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78098       };
78099     }
78100   }
78101   jresult = (void *)result;
78102   return jresult;
78103 }
78104
78105
78106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
78107   void * jresult ;
78108   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
78109   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
78110   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
78111
78112   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
78113   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
78114   if (!arg2) {
78115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
78116     return 0;
78117   }
78118   {
78119     try {
78120       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
78121     } catch (std::out_of_range& e) {
78122       {
78123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78124       };
78125     } catch (std::exception& e) {
78126       {
78127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78128       };
78129     } catch (...) {
78130       {
78131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78132       };
78133     }
78134   }
78135   jresult = (void *)result;
78136   return jresult;
78137 }
78138
78139
78140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
78141   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
78142
78143   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
78144   {
78145     try {
78146       delete arg1;
78147     } catch (std::out_of_range& e) {
78148       {
78149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78150       };
78151     } catch (std::exception& e) {
78152       {
78153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78154       };
78155     } catch (...) {
78156       {
78157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78158       };
78159     }
78160   }
78161 }
78162
78163
78164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
78165   void * jresult ;
78166   Dali::Toolkit::PageFactory *arg1 = 0 ;
78167   Dali::Vector2 *arg2 = 0 ;
78168   Dali::Toolkit::PageTurnLandscapeView result;
78169
78170   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
78171   if (!arg1) {
78172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
78173     return 0;
78174   }
78175   arg2 = (Dali::Vector2 *)jarg2;
78176   if (!arg2) {
78177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
78178     return 0;
78179   }
78180   {
78181     try {
78182       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
78183     } catch (std::out_of_range& e) {
78184       {
78185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78186       };
78187     } catch (std::exception& e) {
78188       {
78189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78190       };
78191     } catch (...) {
78192       {
78193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78194       };
78195     }
78196   }
78197   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
78198   return jresult;
78199 }
78200
78201
78202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
78203   void * jresult ;
78204   Dali::BaseHandle arg1 ;
78205   Dali::BaseHandle *argp1 ;
78206   Dali::Toolkit::PageTurnLandscapeView result;
78207
78208   argp1 = (Dali::BaseHandle *)jarg1;
78209   if (!argp1) {
78210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78211     return 0;
78212   }
78213   arg1 = *argp1;
78214   {
78215     try {
78216       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
78217     } catch (std::out_of_range& e) {
78218       {
78219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78220       };
78221     } catch (std::exception& e) {
78222       {
78223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78224       };
78225     } catch (...) {
78226       {
78227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78228       };
78229     }
78230   }
78231   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
78232   return jresult;
78233 }
78234
78235
78236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
78237   void * jresult ;
78238   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
78239
78240   {
78241     try {
78242       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
78243     } catch (std::out_of_range& e) {
78244       {
78245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78246       };
78247     } catch (std::exception& e) {
78248       {
78249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78250       };
78251     } catch (...) {
78252       {
78253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78254       };
78255     }
78256   }
78257   jresult = (void *)result;
78258   return jresult;
78259 }
78260
78261
78262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
78263   void * jresult ;
78264   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
78265   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
78266
78267   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
78268   if (!arg1) {
78269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
78270     return 0;
78271   }
78272   {
78273     try {
78274       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
78275     } catch (std::out_of_range& e) {
78276       {
78277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78278       };
78279     } catch (std::exception& e) {
78280       {
78281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78282       };
78283     } catch (...) {
78284       {
78285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78286       };
78287     }
78288   }
78289   jresult = (void *)result;
78290   return jresult;
78291 }
78292
78293
78294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
78295   void * jresult ;
78296   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
78297   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
78298   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
78299
78300   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
78301   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
78302   if (!arg2) {
78303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
78304     return 0;
78305   }
78306   {
78307     try {
78308       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
78309     } catch (std::out_of_range& e) {
78310       {
78311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78312       };
78313     } catch (std::exception& e) {
78314       {
78315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78316       };
78317     } catch (...) {
78318       {
78319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78320       };
78321     }
78322   }
78323   jresult = (void *)result;
78324   return jresult;
78325 }
78326
78327
78328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
78329   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
78330
78331   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
78332   {
78333     try {
78334       delete arg1;
78335     } catch (std::out_of_range& e) {
78336       {
78337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78338       };
78339     } catch (std::exception& e) {
78340       {
78341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78342       };
78343     } catch (...) {
78344       {
78345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78346       };
78347     }
78348   }
78349 }
78350
78351
78352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
78353   void * jresult ;
78354   Dali::Toolkit::PageFactory *arg1 = 0 ;
78355   Dali::Vector2 *arg2 = 0 ;
78356   Dali::Toolkit::PageTurnPortraitView result;
78357
78358   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
78359   if (!arg1) {
78360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
78361     return 0;
78362   }
78363   arg2 = (Dali::Vector2 *)jarg2;
78364   if (!arg2) {
78365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
78366     return 0;
78367   }
78368   {
78369     try {
78370       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
78371     } catch (std::out_of_range& e) {
78372       {
78373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78374       };
78375     } catch (std::exception& e) {
78376       {
78377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78378       };
78379     } catch (...) {
78380       {
78381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78382       };
78383     }
78384   }
78385   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
78386   return jresult;
78387 }
78388
78389
78390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
78391   void * jresult ;
78392   Dali::BaseHandle arg1 ;
78393   Dali::BaseHandle *argp1 ;
78394   Dali::Toolkit::PageTurnPortraitView result;
78395
78396   argp1 = (Dali::BaseHandle *)jarg1;
78397   if (!argp1) {
78398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78399     return 0;
78400   }
78401   arg1 = *argp1;
78402   {
78403     try {
78404       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
78405     } catch (std::out_of_range& e) {
78406       {
78407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78408       };
78409     } catch (std::exception& e) {
78410       {
78411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78412       };
78413     } catch (...) {
78414       {
78415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78416       };
78417     }
78418   }
78419   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
78420   return jresult;
78421 }
78422
78423
78424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
78425   int jresult ;
78426   int result;
78427
78428   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
78429   jresult = (int)result;
78430   return jresult;
78431 }
78432
78433
78434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
78435   int jresult ;
78436   int result;
78437
78438   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
78439   jresult = (int)result;
78440   return jresult;
78441 }
78442
78443
78444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
78445   int jresult ;
78446   int result;
78447
78448   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
78449   jresult = (int)result;
78450   return jresult;
78451 }
78452
78453
78454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
78455   void * jresult ;
78456   Dali::Toolkit::ToggleButton::Property *result = 0 ;
78457
78458   {
78459     try {
78460       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
78461     } catch (std::out_of_range& e) {
78462       {
78463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78464       };
78465     } catch (std::exception& e) {
78466       {
78467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78468       };
78469     } catch (...) {
78470       {
78471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78472       };
78473     }
78474   }
78475   jresult = (void *)result;
78476   return jresult;
78477 }
78478
78479
78480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
78481   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
78482
78483   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
78484   {
78485     try {
78486       delete arg1;
78487     } catch (std::out_of_range& e) {
78488       {
78489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78490       };
78491     } catch (std::exception& e) {
78492       {
78493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78494       };
78495     } catch (...) {
78496       {
78497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78498       };
78499     }
78500   }
78501 }
78502
78503
78504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
78505   void * jresult ;
78506   Dali::Toolkit::ToggleButton *result = 0 ;
78507
78508   {
78509     try {
78510       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
78511     } catch (std::out_of_range& e) {
78512       {
78513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78514       };
78515     } catch (std::exception& e) {
78516       {
78517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78518       };
78519     } catch (...) {
78520       {
78521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78522       };
78523     }
78524   }
78525   jresult = (void *)result;
78526   return jresult;
78527 }
78528
78529
78530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
78531   void * jresult ;
78532   Dali::Toolkit::ToggleButton *arg1 = 0 ;
78533   Dali::Toolkit::ToggleButton *result = 0 ;
78534
78535   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
78536   if (!arg1) {
78537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
78538     return 0;
78539   }
78540   {
78541     try {
78542       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
78543     } catch (std::out_of_range& e) {
78544       {
78545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78546       };
78547     } catch (std::exception& e) {
78548       {
78549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78550       };
78551     } catch (...) {
78552       {
78553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78554       };
78555     }
78556   }
78557   jresult = (void *)result;
78558   return jresult;
78559 }
78560
78561
78562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
78563   void * jresult ;
78564   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
78565   Dali::Toolkit::ToggleButton *arg2 = 0 ;
78566   Dali::Toolkit::ToggleButton *result = 0 ;
78567
78568   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
78569   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
78570   if (!arg2) {
78571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
78572     return 0;
78573   }
78574   {
78575     try {
78576       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
78577     } catch (std::out_of_range& e) {
78578       {
78579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78580       };
78581     } catch (std::exception& e) {
78582       {
78583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78584       };
78585     } catch (...) {
78586       {
78587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78588       };
78589     }
78590   }
78591   jresult = (void *)result;
78592   return jresult;
78593 }
78594
78595
78596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
78597   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
78598
78599   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
78600   {
78601     try {
78602       delete arg1;
78603     } catch (std::out_of_range& e) {
78604       {
78605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78606       };
78607     } catch (std::exception& e) {
78608       {
78609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78610       };
78611     } catch (...) {
78612       {
78613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78614       };
78615     }
78616   }
78617 }
78618
78619
78620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
78621   void * jresult ;
78622   Dali::Toolkit::ToggleButton result;
78623
78624   {
78625     try {
78626       result = Dali::Toolkit::ToggleButton::New();
78627     } catch (std::out_of_range& e) {
78628       {
78629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78630       };
78631     } catch (std::exception& e) {
78632       {
78633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78634       };
78635     } catch (...) {
78636       {
78637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78638       };
78639     }
78640   }
78641   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
78642   return jresult;
78643 }
78644
78645
78646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
78647   void * jresult ;
78648   Dali::BaseHandle arg1 ;
78649   Dali::BaseHandle *argp1 ;
78650   Dali::Toolkit::ToggleButton result;
78651
78652   argp1 = (Dali::BaseHandle *)jarg1;
78653   if (!argp1) {
78654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78655     return 0;
78656   }
78657   arg1 = *argp1;
78658   {
78659     try {
78660       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
78661     } catch (std::out_of_range& e) {
78662       {
78663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78664       };
78665     } catch (std::exception& e) {
78666       {
78667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78668       };
78669     } catch (...) {
78670       {
78671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78672       };
78673     }
78674   }
78675   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
78676   return jresult;
78677 }
78678
78679
78680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
78681   void * jresult ;
78682   Dali::Toolkit::Visual::Base *result = 0 ;
78683
78684   {
78685     try {
78686       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
78687     } catch (std::out_of_range& e) {
78688       {
78689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78690       };
78691     } catch (std::exception& e) {
78692       {
78693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78694       };
78695     } catch (...) {
78696       {
78697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78698       };
78699     }
78700   }
78701   jresult = (void *)result;
78702   return jresult;
78703 }
78704
78705
78706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
78707   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78708
78709   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78710   {
78711     try {
78712       delete arg1;
78713     } catch (std::out_of_range& e) {
78714       {
78715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78716       };
78717     } catch (std::exception& e) {
78718       {
78719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78720       };
78721     } catch (...) {
78722       {
78723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78724       };
78725     }
78726   }
78727 }
78728
78729
78730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
78731   void * jresult ;
78732   Dali::Toolkit::Visual::Base *arg1 = 0 ;
78733   Dali::Toolkit::Visual::Base *result = 0 ;
78734
78735   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78736   if (!arg1) {
78737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
78738     return 0;
78739   }
78740   {
78741     try {
78742       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
78743     } catch (std::out_of_range& e) {
78744       {
78745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78746       };
78747     } catch (std::exception& e) {
78748       {
78749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78750       };
78751     } catch (...) {
78752       {
78753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78754       };
78755     }
78756   }
78757   jresult = (void *)result;
78758   return jresult;
78759 }
78760
78761
78762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
78763   void * jresult ;
78764   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78765   Dali::Toolkit::Visual::Base *arg2 = 0 ;
78766   Dali::Toolkit::Visual::Base *result = 0 ;
78767
78768   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78769   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
78770   if (!arg2) {
78771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
78772     return 0;
78773   }
78774   {
78775     try {
78776       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
78777     } catch (std::out_of_range& e) {
78778       {
78779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78780       };
78781     } catch (std::exception& e) {
78782       {
78783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78784       };
78785     } catch (...) {
78786       {
78787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78788       };
78789     }
78790   }
78791   jresult = (void *)result;
78792   return jresult;
78793 }
78794
78795
78796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
78797   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78798   std::string *arg2 = 0 ;
78799
78800   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78801   if (!jarg2) {
78802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78803     return ;
78804   }
78805   std::string arg2_str(jarg2);
78806   arg2 = &arg2_str;
78807   {
78808     try {
78809       (arg1)->SetName((std::string const &)*arg2);
78810     } catch (std::out_of_range& e) {
78811       {
78812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78813       };
78814     } catch (std::exception& e) {
78815       {
78816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78817       };
78818     } catch (...) {
78819       {
78820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78821       };
78822     }
78823   }
78824
78825   //argout typemap for const std::string&
78826
78827 }
78828
78829
78830 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
78831   char * jresult ;
78832   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78833   std::string *result = 0 ;
78834
78835   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78836   {
78837     try {
78838       result = (std::string *) &(arg1)->GetName();
78839     } catch (std::out_of_range& e) {
78840       {
78841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78842       };
78843     } catch (std::exception& e) {
78844       {
78845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78846       };
78847     } catch (...) {
78848       {
78849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78850       };
78851     }
78852   }
78853   jresult = SWIG_csharp_string_callback(result->c_str());
78854   return jresult;
78855 }
78856
78857
78858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
78859   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78860   Dali::Property::Map *arg2 = 0 ;
78861   Dali::Size arg3 ;
78862   Dali::Size *argp3 ;
78863
78864   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78865   arg2 = (Dali::Property::Map *)jarg2;
78866   if (!arg2) {
78867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
78868     return ;
78869   }
78870   argp3 = (Dali::Size *)jarg3;
78871   if (!argp3) {
78872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
78873     return ;
78874   }
78875   arg3 = *argp3;
78876   {
78877     try {
78878       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
78879     } catch (std::out_of_range& e) {
78880       {
78881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78882       };
78883     } catch (std::exception& e) {
78884       {
78885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78886       };
78887     } catch (...) {
78888       {
78889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78890       };
78891     }
78892   }
78893 }
78894
78895
78896 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
78897   float jresult ;
78898   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78899   float arg2 ;
78900   float result;
78901
78902   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78903   arg2 = (float)jarg2;
78904   {
78905     try {
78906       result = (float)(arg1)->GetHeightForWidth(arg2);
78907     } catch (std::out_of_range& e) {
78908       {
78909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78910       };
78911     } catch (std::exception& e) {
78912       {
78913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78914       };
78915     } catch (...) {
78916       {
78917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78918       };
78919     }
78920   }
78921   jresult = result;
78922   return jresult;
78923 }
78924
78925
78926 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
78927   float jresult ;
78928   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78929   float arg2 ;
78930   float result;
78931
78932   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78933   arg2 = (float)jarg2;
78934   {
78935     try {
78936       result = (float)(arg1)->GetWidthForHeight(arg2);
78937     } catch (std::out_of_range& e) {
78938       {
78939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78940       };
78941     } catch (std::exception& e) {
78942       {
78943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78944       };
78945     } catch (...) {
78946       {
78947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78948       };
78949     }
78950   }
78951   jresult = result;
78952   return jresult;
78953 }
78954
78955
78956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
78957   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78958   Dali::Vector2 *arg2 = 0 ;
78959
78960   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78961   arg2 = (Dali::Vector2 *)jarg2;
78962   if (!arg2) {
78963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
78964     return ;
78965   }
78966   {
78967     try {
78968       (arg1)->GetNaturalSize(*arg2);
78969     } catch (std::out_of_range& e) {
78970       {
78971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78972       };
78973     } catch (std::exception& e) {
78974       {
78975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78976       };
78977     } catch (...) {
78978       {
78979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78980       };
78981     }
78982   }
78983 }
78984
78985
78986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
78987   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78988   float arg2 ;
78989
78990   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78991   arg2 = (int)jarg2;
78992   {
78993     try {
78994       (arg1)->SetDepthIndex(arg2);
78995     } catch (std::out_of_range& e) {
78996       {
78997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78998       };
78999     } catch (std::exception& e) {
79000       {
79001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79002       };
79003     } catch (...) {
79004       {
79005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79006       };
79007     }
79008   }
79009 }
79010
79011
79012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
79013   int jresult ;
79014   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
79015   int result;
79016
79017   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
79018   {
79019     try {
79020       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
79021     } catch (std::out_of_range& e) {
79022       {
79023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79024       };
79025     } catch (std::exception& e) {
79026       {
79027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79028       };
79029     } catch (...) {
79030       {
79031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79032       };
79033     }
79034   }
79035   jresult = result;
79036   return jresult;
79037 }
79038
79039
79040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
79041   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
79042   Dali::Property::Map *arg2 = 0 ;
79043
79044   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
79045   arg2 = (Dali::Property::Map *)jarg2;
79046   if (!arg2) {
79047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
79048     return ;
79049   }
79050   {
79051     try {
79052       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
79053     } catch (std::out_of_range& e) {
79054       {
79055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79056       };
79057     } catch (std::exception& e) {
79058       {
79059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79060       };
79061     } catch (...) {
79062       {
79063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79064       };
79065     }
79066   }
79067 }
79068
79069
79070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
79071   void * jresult ;
79072   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
79073   Dali::Toolkit::Visual::Base *result = 0 ;
79074
79075   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
79076   {
79077     try {
79078       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
79079     } catch (std::out_of_range& e) {
79080       {
79081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79082       };
79083     } catch (std::exception& e) {
79084       {
79085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79086       };
79087     } catch (...) {
79088       {
79089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79090       };
79091     }
79092   }
79093   jresult = (void *)result;
79094   return jresult;
79095 }
79096
79097
79098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
79099   void * jresult ;
79100   Dali::Toolkit::VisualFactory result;
79101
79102   {
79103     try {
79104       result = Dali::Toolkit::VisualFactory::Get();
79105     } catch (std::out_of_range& e) {
79106       {
79107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79108       };
79109     } catch (std::exception& e) {
79110       {
79111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79112       };
79113     } catch (...) {
79114       {
79115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79116       };
79117     }
79118   }
79119   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
79120   return jresult;
79121 }
79122
79123
79124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
79125   void * jresult ;
79126   Dali::Toolkit::VisualFactory *result = 0 ;
79127
79128   {
79129     try {
79130       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
79131     } catch (std::out_of_range& e) {
79132       {
79133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79134       };
79135     } catch (std::exception& e) {
79136       {
79137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79138       };
79139     } catch (...) {
79140       {
79141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79142       };
79143     }
79144   }
79145   jresult = (void *)result;
79146   return jresult;
79147 }
79148
79149
79150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
79151   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
79152
79153   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79154   {
79155     try {
79156       delete arg1;
79157     } catch (std::out_of_range& e) {
79158       {
79159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79160       };
79161     } catch (std::exception& e) {
79162       {
79163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79164       };
79165     } catch (...) {
79166       {
79167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79168       };
79169     }
79170   }
79171 }
79172
79173
79174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
79175   void * jresult ;
79176   Dali::Toolkit::VisualFactory *arg1 = 0 ;
79177   Dali::Toolkit::VisualFactory *result = 0 ;
79178
79179   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79180   if (!arg1) {
79181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
79182     return 0;
79183   }
79184   {
79185     try {
79186       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
79187     } catch (std::out_of_range& e) {
79188       {
79189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79190       };
79191     } catch (std::exception& e) {
79192       {
79193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79194       };
79195     } catch (...) {
79196       {
79197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79198       };
79199     }
79200   }
79201   jresult = (void *)result;
79202   return jresult;
79203 }
79204
79205
79206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
79207   void * jresult ;
79208   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
79209   Dali::Toolkit::VisualFactory *arg2 = 0 ;
79210   Dali::Toolkit::VisualFactory *result = 0 ;
79211
79212   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79213   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
79214   if (!arg2) {
79215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
79216     return 0;
79217   }
79218   {
79219     try {
79220       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
79221     } catch (std::out_of_range& e) {
79222       {
79223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79224       };
79225     } catch (std::exception& e) {
79226       {
79227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79228       };
79229     } catch (...) {
79230       {
79231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79232       };
79233     }
79234   }
79235   jresult = (void *)result;
79236   return jresult;
79237 }
79238
79239
79240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
79241   void * jresult ;
79242   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
79243   Dali::Property::Map *arg2 = 0 ;
79244   Dali::Toolkit::Visual::Base result;
79245
79246   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79247   arg2 = (Dali::Property::Map *)jarg2;
79248   if (!arg2) {
79249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
79250     return 0;
79251   }
79252   {
79253     try {
79254       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
79255     } catch (std::out_of_range& e) {
79256       {
79257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79258       };
79259     } catch (std::exception& e) {
79260       {
79261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79262       };
79263     } catch (...) {
79264       {
79265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79266       };
79267     }
79268   }
79269   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
79270   return jresult;
79271 }
79272
79273
79274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
79275   void * jresult ;
79276   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
79277   Dali::Image *arg2 = 0 ;
79278   Dali::Toolkit::Visual::Base result;
79279
79280   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79281   arg2 = (Dali::Image *)jarg2;
79282   if (!arg2) {
79283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
79284     return 0;
79285   }
79286   {
79287     try {
79288       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
79289     } catch (std::out_of_range& e) {
79290       {
79291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79292       };
79293     } catch (std::exception& e) {
79294       {
79295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79296       };
79297     } catch (...) {
79298       {
79299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79300       };
79301     }
79302   }
79303   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
79304   return jresult;
79305 }
79306
79307
79308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
79309   void * jresult ;
79310   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
79311   std::string *arg2 = 0 ;
79312   Dali::ImageDimensions arg3 ;
79313   Dali::ImageDimensions *argp3 ;
79314   Dali::Toolkit::Visual::Base result;
79315
79316   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79317   if (!jarg2) {
79318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79319     return 0;
79320   }
79321   std::string arg2_str(jarg2);
79322   arg2 = &arg2_str;
79323   argp3 = (Dali::ImageDimensions *)jarg3;
79324   if (!argp3) {
79325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
79326     return 0;
79327   }
79328   arg3 = *argp3;
79329   {
79330     try {
79331       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
79332     } catch (std::out_of_range& e) {
79333       {
79334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79335       };
79336     } catch (std::exception& e) {
79337       {
79338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79339       };
79340     } catch (...) {
79341       {
79342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79343       };
79344     }
79345   }
79346   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
79347
79348   //argout typemap for const std::string&
79349
79350   return jresult;
79351 }
79352
79353
79354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
79355   void * jresult ;
79356   Dali::Toolkit::AsyncImageLoader *result = 0 ;
79357
79358   {
79359     try {
79360       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
79361     } catch (std::out_of_range& e) {
79362       {
79363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79364       };
79365     } catch (std::exception& e) {
79366       {
79367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79368       };
79369     } catch (...) {
79370       {
79371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79372       };
79373     }
79374   }
79375   jresult = (void *)result;
79376   return jresult;
79377 }
79378
79379
79380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
79381   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79382
79383   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79384   {
79385     try {
79386       delete arg1;
79387     } catch (std::out_of_range& e) {
79388       {
79389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79390       };
79391     } catch (std::exception& e) {
79392       {
79393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79394       };
79395     } catch (...) {
79396       {
79397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79398       };
79399     }
79400   }
79401 }
79402
79403
79404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
79405   void * jresult ;
79406   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
79407   Dali::Toolkit::AsyncImageLoader *result = 0 ;
79408
79409   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79410   if (!arg1) {
79411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
79412     return 0;
79413   }
79414   {
79415     try {
79416       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
79417     } catch (std::out_of_range& e) {
79418       {
79419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79420       };
79421     } catch (std::exception& e) {
79422       {
79423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79424       };
79425     } catch (...) {
79426       {
79427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79428       };
79429     }
79430   }
79431   jresult = (void *)result;
79432   return jresult;
79433 }
79434
79435
79436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
79437   void * jresult ;
79438   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79439   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
79440   Dali::Toolkit::AsyncImageLoader *result = 0 ;
79441
79442   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79443   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
79444   if (!arg2) {
79445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
79446     return 0;
79447   }
79448   {
79449     try {
79450       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
79451     } catch (std::out_of_range& e) {
79452       {
79453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79454       };
79455     } catch (std::exception& e) {
79456       {
79457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79458       };
79459     } catch (...) {
79460       {
79461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79462       };
79463     }
79464   }
79465   jresult = (void *)result;
79466   return jresult;
79467 }
79468
79469
79470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
79471   void * jresult ;
79472   Dali::Toolkit::AsyncImageLoader result;
79473
79474   {
79475     try {
79476       result = Dali::Toolkit::AsyncImageLoader::New();
79477     } catch (std::out_of_range& e) {
79478       {
79479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79480       };
79481     } catch (std::exception& e) {
79482       {
79483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79484       };
79485     } catch (...) {
79486       {
79487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79488       };
79489     }
79490   }
79491   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
79492   return jresult;
79493 }
79494
79495
79496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
79497   void * jresult ;
79498   Dali::BaseHandle arg1 ;
79499   Dali::BaseHandle *argp1 ;
79500   Dali::Toolkit::AsyncImageLoader result;
79501
79502   argp1 = (Dali::BaseHandle *)jarg1;
79503   if (!argp1) {
79504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79505     return 0;
79506   }
79507   arg1 = *argp1;
79508   {
79509     try {
79510       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
79511     } catch (std::out_of_range& e) {
79512       {
79513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79514       };
79515     } catch (std::exception& e) {
79516       {
79517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79518       };
79519     } catch (...) {
79520       {
79521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79522       };
79523     }
79524   }
79525   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
79526   return jresult;
79527 }
79528
79529
79530 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
79531   unsigned int jresult ;
79532   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79533   std::string *arg2 = 0 ;
79534   uint32_t result;
79535
79536   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79537   if (!jarg2) {
79538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79539     return 0;
79540   }
79541   std::string arg2_str(jarg2);
79542   arg2 = &arg2_str;
79543   {
79544     try {
79545       result = (arg1)->Load((std::string const &)*arg2);
79546     } catch (std::out_of_range& e) {
79547       {
79548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79549       };
79550     } catch (std::exception& e) {
79551       {
79552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79553       };
79554     } catch (...) {
79555       {
79556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79557       };
79558     }
79559   }
79560   jresult = result;
79561
79562   //argout typemap for const std::string&
79563
79564   return jresult;
79565 }
79566
79567
79568 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
79569   unsigned int jresult ;
79570   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79571   std::string *arg2 = 0 ;
79572   Dali::ImageDimensions arg3 ;
79573   Dali::ImageDimensions *argp3 ;
79574   uint32_t result;
79575
79576   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79577   if (!jarg2) {
79578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79579     return 0;
79580   }
79581   std::string arg2_str(jarg2);
79582   arg2 = &arg2_str;
79583   argp3 = (Dali::ImageDimensions *)jarg3;
79584   if (!argp3) {
79585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
79586     return 0;
79587   }
79588   arg3 = *argp3;
79589   {
79590     try {
79591       result = (arg1)->Load((std::string const &)*arg2,arg3);
79592     } catch (std::out_of_range& e) {
79593       {
79594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79595       };
79596     } catch (std::exception& e) {
79597       {
79598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79599       };
79600     } catch (...) {
79601       {
79602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79603       };
79604     }
79605   }
79606   jresult = result;
79607
79608   //argout typemap for const std::string&
79609
79610   return jresult;
79611 }
79612
79613
79614 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
79615   unsigned int jresult ;
79616   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79617   std::string *arg2 = 0 ;
79618   Dali::ImageDimensions arg3 ;
79619   Dali::FittingMode::Type arg4 ;
79620   Dali::SamplingMode::Type arg5 ;
79621   bool arg6 ;
79622   Dali::ImageDimensions *argp3 ;
79623   uint32_t result;
79624
79625   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79626   if (!jarg2) {
79627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79628     return 0;
79629   }
79630   std::string arg2_str(jarg2);
79631   arg2 = &arg2_str;
79632   argp3 = (Dali::ImageDimensions *)jarg3;
79633   if (!argp3) {
79634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
79635     return 0;
79636   }
79637   arg3 = *argp3;
79638   arg4 = (Dali::FittingMode::Type)jarg4;
79639   arg5 = (Dali::SamplingMode::Type)jarg5;
79640   arg6 = jarg6 ? true : false;
79641   {
79642     try {
79643       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
79644     } catch (std::out_of_range& e) {
79645       {
79646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79647       };
79648     } catch (std::exception& e) {
79649       {
79650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79651       };
79652     } catch (...) {
79653       {
79654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79655       };
79656     }
79657   }
79658   jresult = result;
79659
79660   //argout typemap for const std::string&
79661
79662   return jresult;
79663 }
79664
79665
79666 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
79667   unsigned int jresult ;
79668   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79669   uint32_t arg2 ;
79670   bool result;
79671
79672   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79673   arg2 = (uint32_t)jarg2;
79674   {
79675     try {
79676       result = (bool)(arg1)->Cancel(arg2);
79677     } catch (std::out_of_range& e) {
79678       {
79679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79680       };
79681     } catch (std::exception& e) {
79682       {
79683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79684       };
79685     } catch (...) {
79686       {
79687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79688       };
79689     }
79690   }
79691   jresult = result;
79692   return jresult;
79693 }
79694
79695
79696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
79697   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79698
79699   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79700   {
79701     try {
79702       (arg1)->CancelAll();
79703     } catch (std::out_of_range& e) {
79704       {
79705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79706       };
79707     } catch (std::exception& e) {
79708       {
79709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79710       };
79711     } catch (...) {
79712       {
79713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79714       };
79715     }
79716   }
79717 }
79718
79719
79720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
79721   void * jresult ;
79722   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79723   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
79724
79725   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79726   {
79727     try {
79728       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
79729     } catch (std::out_of_range& e) {
79730       {
79731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79732       };
79733     } catch (std::exception& e) {
79734       {
79735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79736       };
79737     } catch (...) {
79738       {
79739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79740       };
79741     }
79742   }
79743   jresult = (void *)result;
79744   return jresult;
79745 }
79746
79747
79748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_2(void * jarg1) {
79749   void * jresult ;
79750   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
79751   Dali::Toolkit::AsyncImageLoader *result = 0 ;
79752
79753   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
79754   {
79755     try {
79756       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
79757     } catch (std::out_of_range& e) {
79758       {
79759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79760       };
79761     } catch (std::exception& e) {
79762       {
79763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79764       };
79765     } catch (...) {
79766       {
79767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79768       };
79769     }
79770   }
79771   jresult = (void *)result;
79772   return jresult;
79773 }
79774
79775
79776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
79777   void * jresult ;
79778   std::string *arg1 = 0 ;
79779   Dali::PixelData result;
79780
79781   if (!jarg1) {
79782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79783     return 0;
79784   }
79785   std::string arg1_str(jarg1);
79786   arg1 = &arg1_str;
79787   {
79788     try {
79789       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
79790     } catch (std::out_of_range& e) {
79791       {
79792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79793       };
79794     } catch (std::exception& e) {
79795       {
79796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79797       };
79798     } catch (...) {
79799       {
79800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79801       };
79802     }
79803   }
79804   jresult = new Dali::PixelData((const Dali::PixelData &)result);
79805
79806   //argout typemap for const std::string&
79807
79808   return jresult;
79809 }
79810
79811
79812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
79813   void * jresult ;
79814   std::string *arg1 = 0 ;
79815   Dali::ImageDimensions arg2 ;
79816   Dali::ImageDimensions *argp2 ;
79817   Dali::PixelData result;
79818
79819   if (!jarg1) {
79820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79821     return 0;
79822   }
79823   std::string arg1_str(jarg1);
79824   arg1 = &arg1_str;
79825   argp2 = (Dali::ImageDimensions *)jarg2;
79826   if (!argp2) {
79827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
79828     return 0;
79829   }
79830   arg2 = *argp2;
79831   {
79832     try {
79833       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
79834     } catch (std::out_of_range& e) {
79835       {
79836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79837       };
79838     } catch (std::exception& e) {
79839       {
79840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79841       };
79842     } catch (...) {
79843       {
79844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79845       };
79846     }
79847   }
79848   jresult = new Dali::PixelData((const Dali::PixelData &)result);
79849
79850   //argout typemap for const std::string&
79851
79852   return jresult;
79853 }
79854
79855
79856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
79857   void * jresult ;
79858   std::string *arg1 = 0 ;
79859   Dali::ImageDimensions arg2 ;
79860   Dali::FittingMode::Type arg3 ;
79861   Dali::SamplingMode::Type arg4 ;
79862   bool arg5 ;
79863   Dali::ImageDimensions *argp2 ;
79864   Dali::PixelData result;
79865
79866   if (!jarg1) {
79867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79868     return 0;
79869   }
79870   std::string arg1_str(jarg1);
79871   arg1 = &arg1_str;
79872   argp2 = (Dali::ImageDimensions *)jarg2;
79873   if (!argp2) {
79874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
79875     return 0;
79876   }
79877   arg2 = *argp2;
79878   arg3 = (Dali::FittingMode::Type)jarg3;
79879   arg4 = (Dali::SamplingMode::Type)jarg4;
79880   arg5 = jarg5 ? true : false;
79881   {
79882     try {
79883       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
79884     } catch (std::out_of_range& e) {
79885       {
79886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79887       };
79888     } catch (std::exception& e) {
79889       {
79890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79891       };
79892     } catch (...) {
79893       {
79894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79895       };
79896     }
79897   }
79898   jresult = new Dali::PixelData((const Dali::PixelData &)result);
79899
79900   //argout typemap for const std::string&
79901
79902   return jresult;
79903 }
79904
79905
79906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
79907   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
79908
79909   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
79910   {
79911     try {
79912       delete arg1;
79913     } catch (std::out_of_range& e) {
79914       {
79915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79916       };
79917     } catch (std::exception& e) {
79918       {
79919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79920       };
79921     } catch (...) {
79922       {
79923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79924       };
79925     }
79926   }
79927 }
79928
79929
79930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
79931   void * jresult ;
79932   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
79933   Dali::Actor arg2 ;
79934   Dali::Actor arg3 ;
79935   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
79936   Dali::Actor *argp2 ;
79937   Dali::Actor *argp3 ;
79938   Dali::Actor result;
79939
79940   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
79941   argp2 = (Dali::Actor *)jarg2;
79942   if (!argp2) {
79943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79944     return 0;
79945   }
79946   arg2 = *argp2;
79947   argp3 = (Dali::Actor *)jarg3;
79948   if (!argp3) {
79949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79950     return 0;
79951   }
79952   arg3 = *argp3;
79953   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
79954   {
79955     try {
79956       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
79957     } catch (std::out_of_range& e) {
79958       {
79959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79960       };
79961     } catch (std::exception& e) {
79962       {
79963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79964       };
79965     } catch (...) {
79966       {
79967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79968       };
79969     }
79970   }
79971   jresult = new Dali::Actor((const Dali::Actor &)result);
79972   return jresult;
79973 }
79974
79975
79976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
79977   void * jresult ;
79978   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
79979
79980   {
79981     try {
79982       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
79983     } catch (std::out_of_range& e) {
79984       {
79985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79986       };
79987     } catch (std::exception& e) {
79988       {
79989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79990       };
79991     } catch (...) {
79992       {
79993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79994       };
79995     }
79996   }
79997   jresult = (void *)result;
79998   return jresult;
79999 }
80000
80001
80002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
80003   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
80004   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
80005   if (director) {
80006     director->swig_connect_director(callback0);
80007   }
80008 }
80009
80010
80011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
80012   KeyboardFocusManager arg1 ;
80013   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
80014   KeyboardFocusManager *argp1 ;
80015
80016   argp1 = (KeyboardFocusManager *)jarg1;
80017   if (!argp1) {
80018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
80019     return ;
80020   }
80021   arg1 = *argp1;
80022   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
80023   if (!arg2) {
80024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
80025     return ;
80026   }
80027   {
80028     try {
80029       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
80030     } catch (std::out_of_range& e) {
80031       {
80032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80033       };
80034     } catch (std::exception& e) {
80035       {
80036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80037       };
80038     } catch (...) {
80039       {
80040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80041       };
80042     }
80043   }
80044 }
80045
80046
80047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
80048   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80049
80050   arg1 = (std::vector< unsigned int > *)jarg1;
80051   {
80052     try {
80053       (arg1)->clear();
80054     } catch (std::out_of_range& e) {
80055       {
80056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80057       };
80058     } catch (std::exception& e) {
80059       {
80060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80061       };
80062     } catch (...) {
80063       {
80064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80065       };
80066     }
80067   }
80068 }
80069
80070
80071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
80072   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80073   unsigned int *arg2 = 0 ;
80074   unsigned int temp2 ;
80075
80076   arg1 = (std::vector< unsigned int > *)jarg1;
80077   temp2 = (unsigned int)jarg2;
80078   arg2 = &temp2;
80079   {
80080     try {
80081       (arg1)->push_back((unsigned int const &)*arg2);
80082     } catch (std::out_of_range& e) {
80083       {
80084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80085       };
80086     } catch (std::exception& e) {
80087       {
80088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80089       };
80090     } catch (...) {
80091       {
80092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80093       };
80094     }
80095   }
80096 }
80097
80098
80099 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
80100   unsigned long jresult ;
80101   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80102   std::vector< unsigned int >::size_type result;
80103
80104   arg1 = (std::vector< unsigned int > *)jarg1;
80105   {
80106     try {
80107       result = ((std::vector< unsigned int > const *)arg1)->size();
80108     } catch (std::out_of_range& e) {
80109       {
80110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80111       };
80112     } catch (std::exception& e) {
80113       {
80114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80115       };
80116     } catch (...) {
80117       {
80118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80119       };
80120     }
80121   }
80122   jresult = (unsigned long)result;
80123   return jresult;
80124 }
80125
80126
80127 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
80128   unsigned long jresult ;
80129   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80130   std::vector< unsigned int >::size_type result;
80131
80132   arg1 = (std::vector< unsigned int > *)jarg1;
80133   {
80134     try {
80135       result = ((std::vector< unsigned int > const *)arg1)->capacity();
80136     } catch (std::out_of_range& e) {
80137       {
80138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80139       };
80140     } catch (std::exception& e) {
80141       {
80142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80143       };
80144     } catch (...) {
80145       {
80146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80147       };
80148     }
80149   }
80150   jresult = (unsigned long)result;
80151   return jresult;
80152 }
80153
80154
80155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
80156   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80157   std::vector< unsigned int >::size_type arg2 ;
80158
80159   arg1 = (std::vector< unsigned int > *)jarg1;
80160   arg2 = (std::vector< unsigned int >::size_type)jarg2;
80161   {
80162     try {
80163       (arg1)->reserve(arg2);
80164     } catch (std::out_of_range& e) {
80165       {
80166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80167       };
80168     } catch (std::exception& e) {
80169       {
80170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80171       };
80172     } catch (...) {
80173       {
80174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80175       };
80176     }
80177   }
80178 }
80179
80180
80181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
80182   void * jresult ;
80183   std::vector< unsigned int > *result = 0 ;
80184
80185   {
80186     try {
80187       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
80188     } catch (std::out_of_range& e) {
80189       {
80190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80191       };
80192     } catch (std::exception& e) {
80193       {
80194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80195       };
80196     } catch (...) {
80197       {
80198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80199       };
80200     }
80201   }
80202   jresult = (void *)result;
80203   return jresult;
80204 }
80205
80206
80207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
80208   void * jresult ;
80209   std::vector< unsigned int > *arg1 = 0 ;
80210   std::vector< unsigned int > *result = 0 ;
80211
80212   arg1 = (std::vector< unsigned int > *)jarg1;
80213   if (!arg1) {
80214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
80215     return 0;
80216   }
80217   {
80218     try {
80219       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
80220     } catch (std::out_of_range& e) {
80221       {
80222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80223       };
80224     } catch (std::exception& e) {
80225       {
80226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80227       };
80228     } catch (...) {
80229       {
80230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80231       };
80232     }
80233   }
80234   jresult = (void *)result;
80235   return jresult;
80236 }
80237
80238
80239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
80240   void * jresult ;
80241   int arg1 ;
80242   std::vector< unsigned int > *result = 0 ;
80243
80244   arg1 = (int)jarg1;
80245   {
80246     try {
80247       try {
80248         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
80249       }
80250       catch(std::out_of_range &_e) {
80251         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80252         return 0;
80253       }
80254
80255     } catch (std::out_of_range& e) {
80256       {
80257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80258       };
80259     } catch (std::exception& e) {
80260       {
80261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80262       };
80263     } catch (...) {
80264       {
80265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80266       };
80267     }
80268   }
80269   jresult = (void *)result;
80270   return jresult;
80271 }
80272
80273
80274 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
80275   unsigned int jresult ;
80276   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80277   int arg2 ;
80278   unsigned int result;
80279
80280   arg1 = (std::vector< unsigned int > *)jarg1;
80281   arg2 = (int)jarg2;
80282   {
80283     try {
80284       try {
80285         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
80286       }
80287       catch(std::out_of_range &_e) {
80288         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80289         return 0;
80290       }
80291
80292     } catch (std::out_of_range& e) {
80293       {
80294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80295       };
80296     } catch (std::exception& e) {
80297       {
80298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80299       };
80300     } catch (...) {
80301       {
80302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80303       };
80304     }
80305   }
80306   jresult = result;
80307   return jresult;
80308 }
80309
80310
80311 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
80312   unsigned int jresult ;
80313   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80314   int arg2 ;
80315   unsigned int *result = 0 ;
80316
80317   arg1 = (std::vector< unsigned int > *)jarg1;
80318   arg2 = (int)jarg2;
80319   {
80320     try {
80321       try {
80322         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
80323       }
80324       catch(std::out_of_range &_e) {
80325         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80326         return 0;
80327       }
80328
80329     } catch (std::out_of_range& e) {
80330       {
80331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80332       };
80333     } catch (std::exception& e) {
80334       {
80335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80336       };
80337     } catch (...) {
80338       {
80339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80340       };
80341     }
80342   }
80343   jresult = *result;
80344   return jresult;
80345 }
80346
80347
80348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
80349   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80350   int arg2 ;
80351   unsigned int *arg3 = 0 ;
80352   unsigned int temp3 ;
80353
80354   arg1 = (std::vector< unsigned int > *)jarg1;
80355   arg2 = (int)jarg2;
80356   temp3 = (unsigned int)jarg3;
80357   arg3 = &temp3;
80358   {
80359     try {
80360       try {
80361         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
80362       }
80363       catch(std::out_of_range &_e) {
80364         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80365         return ;
80366       }
80367
80368     } catch (std::out_of_range& e) {
80369       {
80370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80371       };
80372     } catch (std::exception& e) {
80373       {
80374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80375       };
80376     } catch (...) {
80377       {
80378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80379       };
80380     }
80381   }
80382 }
80383
80384
80385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
80386   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80387   std::vector< unsigned int > *arg2 = 0 ;
80388
80389   arg1 = (std::vector< unsigned int > *)jarg1;
80390   arg2 = (std::vector< unsigned int > *)jarg2;
80391   if (!arg2) {
80392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
80393     return ;
80394   }
80395   {
80396     try {
80397       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
80398     } catch (std::out_of_range& e) {
80399       {
80400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80401       };
80402     } catch (std::exception& e) {
80403       {
80404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80405       };
80406     } catch (...) {
80407       {
80408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80409       };
80410     }
80411   }
80412 }
80413
80414
80415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
80416   void * jresult ;
80417   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80418   int arg2 ;
80419   int arg3 ;
80420   std::vector< unsigned int > *result = 0 ;
80421
80422   arg1 = (std::vector< unsigned int > *)jarg1;
80423   arg2 = (int)jarg2;
80424   arg3 = (int)jarg3;
80425   {
80426     try {
80427       try {
80428         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
80429       }
80430       catch(std::out_of_range &_e) {
80431         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80432         return 0;
80433       }
80434       catch(std::invalid_argument &_e) {
80435         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
80436         return 0;
80437       }
80438
80439     } catch (std::out_of_range& e) {
80440       {
80441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80442       };
80443     } catch (std::exception& e) {
80444       {
80445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80446       };
80447     } catch (...) {
80448       {
80449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80450       };
80451     }
80452   }
80453   jresult = (void *)result;
80454   return jresult;
80455 }
80456
80457
80458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
80459   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80460   int arg2 ;
80461   unsigned int *arg3 = 0 ;
80462   unsigned int temp3 ;
80463
80464   arg1 = (std::vector< unsigned int > *)jarg1;
80465   arg2 = (int)jarg2;
80466   temp3 = (unsigned int)jarg3;
80467   arg3 = &temp3;
80468   {
80469     try {
80470       try {
80471         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
80472       }
80473       catch(std::out_of_range &_e) {
80474         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80475         return ;
80476       }
80477
80478     } catch (std::out_of_range& e) {
80479       {
80480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80481       };
80482     } catch (std::exception& e) {
80483       {
80484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80485       };
80486     } catch (...) {
80487       {
80488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80489       };
80490     }
80491   }
80492 }
80493
80494
80495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
80496   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80497   int arg2 ;
80498   std::vector< unsigned int > *arg3 = 0 ;
80499
80500   arg1 = (std::vector< unsigned int > *)jarg1;
80501   arg2 = (int)jarg2;
80502   arg3 = (std::vector< unsigned int > *)jarg3;
80503   if (!arg3) {
80504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
80505     return ;
80506   }
80507   {
80508     try {
80509       try {
80510         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
80511       }
80512       catch(std::out_of_range &_e) {
80513         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80514         return ;
80515       }
80516
80517     } catch (std::out_of_range& e) {
80518       {
80519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80520       };
80521     } catch (std::exception& e) {
80522       {
80523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80524       };
80525     } catch (...) {
80526       {
80527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80528       };
80529     }
80530   }
80531 }
80532
80533
80534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
80535   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80536   int arg2 ;
80537
80538   arg1 = (std::vector< unsigned int > *)jarg1;
80539   arg2 = (int)jarg2;
80540   {
80541     try {
80542       try {
80543         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
80544       }
80545       catch(std::out_of_range &_e) {
80546         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80547         return ;
80548       }
80549
80550     } catch (std::out_of_range& e) {
80551       {
80552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80553       };
80554     } catch (std::exception& e) {
80555       {
80556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80557       };
80558     } catch (...) {
80559       {
80560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80561       };
80562     }
80563   }
80564 }
80565
80566
80567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
80568   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80569   int arg2 ;
80570   int arg3 ;
80571
80572   arg1 = (std::vector< unsigned int > *)jarg1;
80573   arg2 = (int)jarg2;
80574   arg3 = (int)jarg3;
80575   {
80576     try {
80577       try {
80578         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
80579       }
80580       catch(std::out_of_range &_e) {
80581         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80582         return ;
80583       }
80584       catch(std::invalid_argument &_e) {
80585         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
80586         return ;
80587       }
80588
80589     } catch (std::out_of_range& e) {
80590       {
80591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80592       };
80593     } catch (std::exception& e) {
80594       {
80595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80596       };
80597     } catch (...) {
80598       {
80599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80600       };
80601     }
80602   }
80603 }
80604
80605
80606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
80607   void * jresult ;
80608   unsigned int *arg1 = 0 ;
80609   int arg2 ;
80610   unsigned int temp1 ;
80611   std::vector< unsigned int > *result = 0 ;
80612
80613   temp1 = (unsigned int)jarg1;
80614   arg1 = &temp1;
80615   arg2 = (int)jarg2;
80616   {
80617     try {
80618       try {
80619         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
80620       }
80621       catch(std::out_of_range &_e) {
80622         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80623         return 0;
80624       }
80625
80626     } catch (std::out_of_range& e) {
80627       {
80628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80629       };
80630     } catch (std::exception& e) {
80631       {
80632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80633       };
80634     } catch (...) {
80635       {
80636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80637       };
80638     }
80639   }
80640   jresult = (void *)result;
80641   return jresult;
80642 }
80643
80644
80645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
80646   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80647
80648   arg1 = (std::vector< unsigned int > *)jarg1;
80649   {
80650     try {
80651       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
80652     } catch (std::out_of_range& e) {
80653       {
80654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80655       };
80656     } catch (std::exception& e) {
80657       {
80658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80659       };
80660     } catch (...) {
80661       {
80662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80663       };
80664     }
80665   }
80666 }
80667
80668
80669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
80670   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80671   int arg2 ;
80672   int arg3 ;
80673
80674   arg1 = (std::vector< unsigned int > *)jarg1;
80675   arg2 = (int)jarg2;
80676   arg3 = (int)jarg3;
80677   {
80678     try {
80679       try {
80680         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
80681       }
80682       catch(std::out_of_range &_e) {
80683         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80684         return ;
80685       }
80686       catch(std::invalid_argument &_e) {
80687         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
80688         return ;
80689       }
80690
80691     } catch (std::out_of_range& e) {
80692       {
80693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80694       };
80695     } catch (std::exception& e) {
80696       {
80697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80698       };
80699     } catch (...) {
80700       {
80701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80702       };
80703     }
80704   }
80705 }
80706
80707
80708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
80709   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80710   int arg2 ;
80711   std::vector< unsigned int > *arg3 = 0 ;
80712
80713   arg1 = (std::vector< unsigned int > *)jarg1;
80714   arg2 = (int)jarg2;
80715   arg3 = (std::vector< unsigned int > *)jarg3;
80716   if (!arg3) {
80717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
80718     return ;
80719   }
80720   {
80721     try {
80722       try {
80723         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
80724       }
80725       catch(std::out_of_range &_e) {
80726         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80727         return ;
80728       }
80729
80730     } catch (std::out_of_range& e) {
80731       {
80732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80733       };
80734     } catch (std::exception& e) {
80735       {
80736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80737       };
80738     } catch (...) {
80739       {
80740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80741       };
80742     }
80743   }
80744 }
80745
80746
80747 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
80748   unsigned int jresult ;
80749   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80750   unsigned int *arg2 = 0 ;
80751   unsigned int temp2 ;
80752   bool result;
80753
80754   arg1 = (std::vector< unsigned int > *)jarg1;
80755   temp2 = (unsigned int)jarg2;
80756   arg2 = &temp2;
80757   {
80758     try {
80759       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
80760     } catch (std::out_of_range& e) {
80761       {
80762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80763       };
80764     } catch (std::exception& e) {
80765       {
80766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80767       };
80768     } catch (...) {
80769       {
80770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80771       };
80772     }
80773   }
80774   jresult = result;
80775   return jresult;
80776 }
80777
80778
80779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
80780   int jresult ;
80781   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80782   unsigned int *arg2 = 0 ;
80783   unsigned int temp2 ;
80784   int result;
80785
80786   arg1 = (std::vector< unsigned int > *)jarg1;
80787   temp2 = (unsigned int)jarg2;
80788   arg2 = &temp2;
80789   {
80790     try {
80791       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
80792     } catch (std::out_of_range& e) {
80793       {
80794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80795       };
80796     } catch (std::exception& e) {
80797       {
80798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80799       };
80800     } catch (...) {
80801       {
80802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80803       };
80804     }
80805   }
80806   jresult = result;
80807   return jresult;
80808 }
80809
80810
80811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
80812   int jresult ;
80813   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80814   unsigned int *arg2 = 0 ;
80815   unsigned int temp2 ;
80816   int result;
80817
80818   arg1 = (std::vector< unsigned int > *)jarg1;
80819   temp2 = (unsigned int)jarg2;
80820   arg2 = &temp2;
80821   {
80822     try {
80823       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
80824     } catch (std::out_of_range& e) {
80825       {
80826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80827       };
80828     } catch (std::exception& e) {
80829       {
80830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80831       };
80832     } catch (...) {
80833       {
80834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80835       };
80836     }
80837   }
80838   jresult = result;
80839   return jresult;
80840 }
80841
80842
80843 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
80844   unsigned int jresult ;
80845   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80846   unsigned int *arg2 = 0 ;
80847   unsigned int temp2 ;
80848   bool result;
80849
80850   arg1 = (std::vector< unsigned int > *)jarg1;
80851   temp2 = (unsigned int)jarg2;
80852   arg2 = &temp2;
80853   {
80854     try {
80855       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
80856     } catch (std::out_of_range& e) {
80857       {
80858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80859       };
80860     } catch (std::exception& e) {
80861       {
80862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80863       };
80864     } catch (...) {
80865       {
80866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80867       };
80868     }
80869   }
80870   jresult = result;
80871   return jresult;
80872 }
80873
80874
80875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
80876   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80877
80878   arg1 = (std::vector< unsigned int > *)jarg1;
80879   {
80880     try {
80881       delete arg1;
80882     } catch (std::out_of_range& e) {
80883       {
80884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80885       };
80886     } catch (std::exception& e) {
80887       {
80888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80889       };
80890     } catch (...) {
80891       {
80892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80893       };
80894     }
80895   }
80896 }
80897
80898
80899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
80900   void * jresult ;
80901   std::pair< unsigned int,Dali::Actor > *result = 0 ;
80902
80903   {
80904     try {
80905       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
80906     } catch (std::out_of_range& e) {
80907       {
80908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80909       };
80910     } catch (std::exception& e) {
80911       {
80912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80913       };
80914     } catch (...) {
80915       {
80916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80917       };
80918     }
80919   }
80920   jresult = (void *)result;
80921   return jresult;
80922 }
80923
80924
80925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
80926   void * jresult ;
80927   unsigned int arg1 ;
80928   Dali::Actor arg2 ;
80929   Dali::Actor *argp2 ;
80930   std::pair< unsigned int,Dali::Actor > *result = 0 ;
80931
80932   arg1 = (unsigned int)jarg1;
80933   argp2 = (Dali::Actor *)jarg2;
80934   if (!argp2) {
80935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80936     return 0;
80937   }
80938   arg2 = *argp2;
80939   {
80940     try {
80941       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
80942     } catch (std::out_of_range& e) {
80943       {
80944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80945       };
80946     } catch (std::exception& e) {
80947       {
80948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80949       };
80950     } catch (...) {
80951       {
80952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80953       };
80954     }
80955   }
80956   jresult = (void *)result;
80957   return jresult;
80958 }
80959
80960
80961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
80962   void * jresult ;
80963   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
80964   std::pair< unsigned int,Dali::Actor > *result = 0 ;
80965
80966   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
80967   if (!arg1) {
80968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
80969     return 0;
80970   }
80971   {
80972     try {
80973       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
80974     } catch (std::out_of_range& e) {
80975       {
80976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80977       };
80978     } catch (std::exception& e) {
80979       {
80980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80981       };
80982     } catch (...) {
80983       {
80984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80985       };
80986     }
80987   }
80988   jresult = (void *)result;
80989   return jresult;
80990 }
80991
80992
80993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
80994   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
80995   unsigned int arg2 ;
80996
80997   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
80998   arg2 = (unsigned int)jarg2;
80999   if (arg1) (arg1)->first = arg2;
81000 }
81001
81002
81003 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
81004   unsigned int jresult ;
81005   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
81006   unsigned int result;
81007
81008   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81009   result = (unsigned int) ((arg1)->first);
81010   jresult = result;
81011   return jresult;
81012 }
81013
81014
81015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
81016   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
81017   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
81018
81019   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81020   arg2 = (Dali::Actor *)jarg2;
81021   if (arg1) (arg1)->second = *arg2;
81022 }
81023
81024
81025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
81026   void * jresult ;
81027   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
81028   Dali::Actor *result = 0 ;
81029
81030   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81031   result = (Dali::Actor *)& ((arg1)->second);
81032   jresult = (void *)result;
81033   return jresult;
81034 }
81035
81036
81037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
81038   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
81039
81040   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81041   {
81042     try {
81043       delete arg1;
81044     } catch (std::out_of_range& e) {
81045       {
81046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81047       };
81048     } catch (std::exception& e) {
81049       {
81050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81051       };
81052     } catch (...) {
81053       {
81054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81055       };
81056     }
81057   }
81058 }
81059
81060
81061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
81062   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81063
81064   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81065   {
81066     try {
81067       (arg1)->clear();
81068     } catch (std::out_of_range& e) {
81069       {
81070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81071       };
81072     } catch (std::exception& e) {
81073       {
81074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81075       };
81076     } catch (...) {
81077       {
81078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81079       };
81080     }
81081   }
81082 }
81083
81084
81085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
81086   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81087   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
81088
81089   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81090   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
81091   if (!arg2) {
81092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
81093     return ;
81094   }
81095   {
81096     try {
81097       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
81098     } catch (std::out_of_range& e) {
81099       {
81100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81101       };
81102     } catch (std::exception& e) {
81103       {
81104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81105       };
81106     } catch (...) {
81107       {
81108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81109       };
81110     }
81111   }
81112 }
81113
81114
81115 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
81116   unsigned long jresult ;
81117   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81118   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
81119
81120   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81121   {
81122     try {
81123       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
81124     } catch (std::out_of_range& e) {
81125       {
81126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81127       };
81128     } catch (std::exception& e) {
81129       {
81130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81131       };
81132     } catch (...) {
81133       {
81134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81135       };
81136     }
81137   }
81138   jresult = (unsigned long)result;
81139   return jresult;
81140 }
81141
81142
81143 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
81144   unsigned long jresult ;
81145   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81146   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
81147
81148   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81149   {
81150     try {
81151       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
81152     } catch (std::out_of_range& e) {
81153       {
81154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81155       };
81156     } catch (std::exception& e) {
81157       {
81158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81159       };
81160     } catch (...) {
81161       {
81162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81163       };
81164     }
81165   }
81166   jresult = (unsigned long)result;
81167   return jresult;
81168 }
81169
81170
81171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
81172   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81173   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
81174
81175   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81176   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
81177   {
81178     try {
81179       (arg1)->reserve(arg2);
81180     } catch (std::out_of_range& e) {
81181       {
81182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81183       };
81184     } catch (std::exception& e) {
81185       {
81186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81187       };
81188     } catch (...) {
81189       {
81190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81191       };
81192     }
81193   }
81194 }
81195
81196
81197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
81198   void * jresult ;
81199   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
81200
81201   {
81202     try {
81203       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
81204     } catch (std::out_of_range& e) {
81205       {
81206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81207       };
81208     } catch (std::exception& e) {
81209       {
81210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81211       };
81212     } catch (...) {
81213       {
81214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81215       };
81216     }
81217   }
81218   jresult = (void *)result;
81219   return jresult;
81220 }
81221
81222
81223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
81224   void * jresult ;
81225   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
81226   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
81227
81228   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81229   if (!arg1) {
81230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
81231     return 0;
81232   }
81233   {
81234     try {
81235       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);
81236     } catch (std::out_of_range& e) {
81237       {
81238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81239       };
81240     } catch (std::exception& e) {
81241       {
81242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81243       };
81244     } catch (...) {
81245       {
81246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81247       };
81248     }
81249   }
81250   jresult = (void *)result;
81251   return jresult;
81252 }
81253
81254
81255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
81256   void * jresult ;
81257   int arg1 ;
81258   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
81259
81260   arg1 = (int)jarg1;
81261   {
81262     try {
81263       try {
81264         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);
81265       }
81266       catch(std::out_of_range &_e) {
81267         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81268         return 0;
81269       }
81270
81271     } catch (std::out_of_range& e) {
81272       {
81273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81274       };
81275     } catch (std::exception& e) {
81276       {
81277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81278       };
81279     } catch (...) {
81280       {
81281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81282       };
81283     }
81284   }
81285   jresult = (void *)result;
81286   return jresult;
81287 }
81288
81289
81290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
81291   void * jresult ;
81292   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81293   int arg2 ;
81294   std::pair< unsigned int,Dali::Actor > result;
81295
81296   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81297   arg2 = (int)jarg2;
81298   {
81299     try {
81300       try {
81301         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
81302       }
81303       catch(std::out_of_range &_e) {
81304         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81305         return 0;
81306       }
81307
81308     } catch (std::out_of_range& e) {
81309       {
81310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81311       };
81312     } catch (std::exception& e) {
81313       {
81314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81315       };
81316     } catch (...) {
81317       {
81318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81319       };
81320     }
81321   }
81322   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
81323   return jresult;
81324 }
81325
81326
81327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
81328   void * jresult ;
81329   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81330   int arg2 ;
81331   std::pair< unsigned int,Dali::Actor > *result = 0 ;
81332
81333   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81334   arg2 = (int)jarg2;
81335   {
81336     try {
81337       try {
81338         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
81339       }
81340       catch(std::out_of_range &_e) {
81341         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81342         return 0;
81343       }
81344
81345     } catch (std::out_of_range& e) {
81346       {
81347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81348       };
81349     } catch (std::exception& e) {
81350       {
81351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81352       };
81353     } catch (...) {
81354       {
81355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81356       };
81357     }
81358   }
81359   jresult = (void *)result;
81360   return jresult;
81361 }
81362
81363
81364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
81365   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81366   int arg2 ;
81367   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
81368
81369   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81370   arg2 = (int)jarg2;
81371   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
81372   if (!arg3) {
81373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
81374     return ;
81375   }
81376   {
81377     try {
81378       try {
81379         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);
81380       }
81381       catch(std::out_of_range &_e) {
81382         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81383         return ;
81384       }
81385
81386     } catch (std::out_of_range& e) {
81387       {
81388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81389       };
81390     } catch (std::exception& e) {
81391       {
81392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81393       };
81394     } catch (...) {
81395       {
81396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81397       };
81398     }
81399   }
81400 }
81401
81402
81403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
81404   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81405   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
81406
81407   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81408   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
81409   if (!arg2) {
81410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
81411     return ;
81412   }
81413   {
81414     try {
81415       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);
81416     } catch (std::out_of_range& e) {
81417       {
81418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81419       };
81420     } catch (std::exception& e) {
81421       {
81422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81423       };
81424     } catch (...) {
81425       {
81426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81427       };
81428     }
81429   }
81430 }
81431
81432
81433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
81434   void * jresult ;
81435   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81436   int arg2 ;
81437   int arg3 ;
81438   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
81439
81440   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81441   arg2 = (int)jarg2;
81442   arg3 = (int)jarg3;
81443   {
81444     try {
81445       try {
81446         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);
81447       }
81448       catch(std::out_of_range &_e) {
81449         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81450         return 0;
81451       }
81452       catch(std::invalid_argument &_e) {
81453         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
81454         return 0;
81455       }
81456
81457     } catch (std::out_of_range& e) {
81458       {
81459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81460       };
81461     } catch (std::exception& e) {
81462       {
81463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81464       };
81465     } catch (...) {
81466       {
81467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81468       };
81469     }
81470   }
81471   jresult = (void *)result;
81472   return jresult;
81473 }
81474
81475
81476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
81477   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81478   int arg2 ;
81479   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
81480
81481   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81482   arg2 = (int)jarg2;
81483   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
81484   if (!arg3) {
81485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
81486     return ;
81487   }
81488   {
81489     try {
81490       try {
81491         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);
81492       }
81493       catch(std::out_of_range &_e) {
81494         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81495         return ;
81496       }
81497
81498     } catch (std::out_of_range& e) {
81499       {
81500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81501       };
81502     } catch (std::exception& e) {
81503       {
81504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81505       };
81506     } catch (...) {
81507       {
81508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81509       };
81510     }
81511   }
81512 }
81513
81514
81515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
81516   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81517   int arg2 ;
81518   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
81519
81520   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81521   arg2 = (int)jarg2;
81522   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
81523   if (!arg3) {
81524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
81525     return ;
81526   }
81527   {
81528     try {
81529       try {
81530         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);
81531       }
81532       catch(std::out_of_range &_e) {
81533         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81534         return ;
81535       }
81536
81537     } catch (std::out_of_range& e) {
81538       {
81539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81540       };
81541     } catch (std::exception& e) {
81542       {
81543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81544       };
81545     } catch (...) {
81546       {
81547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81548       };
81549     }
81550   }
81551 }
81552
81553
81554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
81555   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81556   int arg2 ;
81557
81558   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81559   arg2 = (int)jarg2;
81560   {
81561     try {
81562       try {
81563         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
81564       }
81565       catch(std::out_of_range &_e) {
81566         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81567         return ;
81568       }
81569
81570     } catch (std::out_of_range& e) {
81571       {
81572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81573       };
81574     } catch (std::exception& e) {
81575       {
81576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81577       };
81578     } catch (...) {
81579       {
81580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81581       };
81582     }
81583   }
81584 }
81585
81586
81587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
81588   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81589   int arg2 ;
81590   int arg3 ;
81591
81592   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81593   arg2 = (int)jarg2;
81594   arg3 = (int)jarg3;
81595   {
81596     try {
81597       try {
81598         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
81599       }
81600       catch(std::out_of_range &_e) {
81601         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81602         return ;
81603       }
81604       catch(std::invalid_argument &_e) {
81605         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
81606         return ;
81607       }
81608
81609     } catch (std::out_of_range& e) {
81610       {
81611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81612       };
81613     } catch (std::exception& e) {
81614       {
81615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81616       };
81617     } catch (...) {
81618       {
81619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81620       };
81621     }
81622   }
81623 }
81624
81625
81626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
81627   void * jresult ;
81628   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
81629   int arg2 ;
81630   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
81631
81632   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81633   if (!arg1) {
81634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
81635     return 0;
81636   }
81637   arg2 = (int)jarg2;
81638   {
81639     try {
81640       try {
81641         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);
81642       }
81643       catch(std::out_of_range &_e) {
81644         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81645         return 0;
81646       }
81647
81648     } catch (std::out_of_range& e) {
81649       {
81650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81651       };
81652     } catch (std::exception& e) {
81653       {
81654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81655       };
81656     } catch (...) {
81657       {
81658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81659       };
81660     }
81661   }
81662   jresult = (void *)result;
81663   return jresult;
81664 }
81665
81666
81667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
81668   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81669
81670   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81671   {
81672     try {
81673       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
81674     } catch (std::out_of_range& e) {
81675       {
81676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81677       };
81678     } catch (std::exception& e) {
81679       {
81680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81681       };
81682     } catch (...) {
81683       {
81684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81685       };
81686     }
81687   }
81688 }
81689
81690
81691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
81692   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81693   int arg2 ;
81694   int arg3 ;
81695
81696   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81697   arg2 = (int)jarg2;
81698   arg3 = (int)jarg3;
81699   {
81700     try {
81701       try {
81702         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
81703       }
81704       catch(std::out_of_range &_e) {
81705         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81706         return ;
81707       }
81708       catch(std::invalid_argument &_e) {
81709         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
81710         return ;
81711       }
81712
81713     } catch (std::out_of_range& e) {
81714       {
81715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81716       };
81717     } catch (std::exception& e) {
81718       {
81719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81720       };
81721     } catch (...) {
81722       {
81723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81724       };
81725     }
81726   }
81727 }
81728
81729
81730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
81731   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81732   int arg2 ;
81733   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
81734
81735   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81736   arg2 = (int)jarg2;
81737   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
81738   if (!arg3) {
81739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
81740     return ;
81741   }
81742   {
81743     try {
81744       try {
81745         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);
81746       }
81747       catch(std::out_of_range &_e) {
81748         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81749         return ;
81750       }
81751
81752     } catch (std::out_of_range& e) {
81753       {
81754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81755       };
81756     } catch (std::exception& e) {
81757       {
81758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81759       };
81760     } catch (...) {
81761       {
81762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81763       };
81764     }
81765   }
81766 }
81767
81768
81769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
81770   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81771
81772   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81773   {
81774     try {
81775       delete arg1;
81776     } catch (std::out_of_range& e) {
81777       {
81778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81779       };
81780     } catch (std::exception& e) {
81781       {
81782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81783       };
81784     } catch (...) {
81785       {
81786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81787       };
81788     }
81789   }
81790 }
81791
81792
81793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
81794   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
81795
81796   arg1 = (std::vector< Dali::Actor > *)jarg1;
81797   {
81798     try {
81799       (arg1)->clear();
81800     } catch (std::out_of_range& e) {
81801       {
81802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81803       };
81804     } catch (std::exception& e) {
81805       {
81806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81807       };
81808     } catch (...) {
81809       {
81810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81811       };
81812     }
81813   }
81814 }
81815
81816
81817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
81818   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
81819   Dali::Actor *arg2 = 0 ;
81820
81821   arg1 = (std::vector< Dali::Actor > *)jarg1;
81822   arg2 = (Dali::Actor *)jarg2;
81823   if (!arg2) {
81824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
81825     return ;
81826   }
81827   {
81828     try {
81829       (arg1)->push_back((Dali::Actor const &)*arg2);
81830     } catch (std::out_of_range& e) {
81831       {
81832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81833       };
81834     } catch (std::exception& e) {
81835       {
81836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81837       };
81838     } catch (...) {
81839       {
81840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81841       };
81842     }
81843   }
81844 }
81845
81846
81847 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
81848   unsigned long jresult ;
81849   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
81850   std::vector< Dali::Actor >::size_type result;
81851
81852   arg1 = (std::vector< Dali::Actor > *)jarg1;
81853   {
81854     try {
81855       result = ((std::vector< Dali::Actor > const *)arg1)->size();
81856     } catch (std::out_of_range& e) {
81857       {
81858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81859       };
81860     } catch (std::exception& e) {
81861       {
81862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81863       };
81864     } catch (...) {
81865       {
81866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81867       };
81868     }
81869   }
81870   jresult = (unsigned long)result;
81871   return jresult;
81872 }
81873
81874
81875 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
81876   unsigned long jresult ;
81877   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
81878   std::vector< Dali::Actor >::size_type result;
81879
81880   arg1 = (std::vector< Dali::Actor > *)jarg1;
81881   {
81882     try {
81883       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
81884     } catch (std::out_of_range& e) {
81885       {
81886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81887       };
81888     } catch (std::exception& e) {
81889       {
81890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81891       };
81892     } catch (...) {
81893       {
81894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81895       };
81896     }
81897   }
81898   jresult = (unsigned long)result;
81899   return jresult;
81900 }
81901
81902
81903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
81904   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
81905   std::vector< Dali::Actor >::size_type arg2 ;
81906
81907   arg1 = (std::vector< Dali::Actor > *)jarg1;
81908   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
81909   {
81910     try {
81911       (arg1)->reserve(arg2);
81912     } catch (std::out_of_range& e) {
81913       {
81914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81915       };
81916     } catch (std::exception& e) {
81917       {
81918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81919       };
81920     } catch (...) {
81921       {
81922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81923       };
81924     }
81925   }
81926 }
81927
81928
81929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
81930   void * jresult ;
81931   std::vector< Dali::Actor > *result = 0 ;
81932
81933   {
81934     try {
81935       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
81936     } catch (std::out_of_range& e) {
81937       {
81938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81939       };
81940     } catch (std::exception& e) {
81941       {
81942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81943       };
81944     } catch (...) {
81945       {
81946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81947       };
81948     }
81949   }
81950   jresult = (void *)result;
81951   return jresult;
81952 }
81953
81954
81955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
81956   void * jresult ;
81957   std::vector< Dali::Actor > *arg1 = 0 ;
81958   std::vector< Dali::Actor > *result = 0 ;
81959
81960   arg1 = (std::vector< Dali::Actor > *)jarg1;
81961   if (!arg1) {
81962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
81963     return 0;
81964   }
81965   {
81966     try {
81967       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
81968     } catch (std::out_of_range& e) {
81969       {
81970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81971       };
81972     } catch (std::exception& e) {
81973       {
81974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81975       };
81976     } catch (...) {
81977       {
81978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81979       };
81980     }
81981   }
81982   jresult = (void *)result;
81983   return jresult;
81984 }
81985
81986
81987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
81988   void * jresult ;
81989   int arg1 ;
81990   std::vector< Dali::Actor > *result = 0 ;
81991
81992   arg1 = (int)jarg1;
81993   {
81994     try {
81995       try {
81996         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
81997       }
81998       catch(std::out_of_range &_e) {
81999         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82000         return 0;
82001       }
82002
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_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
82023   void * jresult ;
82024   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82025   int arg2 ;
82026   Dali::Actor result;
82027
82028   arg1 = (std::vector< Dali::Actor > *)jarg1;
82029   arg2 = (int)jarg2;
82030   {
82031     try {
82032       try {
82033         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
82034       }
82035       catch(std::out_of_range &_e) {
82036         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82037         return 0;
82038       }
82039
82040     } catch (std::out_of_range& e) {
82041       {
82042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82043       };
82044     } catch (std::exception& e) {
82045       {
82046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82047       };
82048     } catch (...) {
82049       {
82050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82051       };
82052     }
82053   }
82054   jresult = new Dali::Actor((const Dali::Actor &)result);
82055   return jresult;
82056 }
82057
82058
82059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
82060   void * jresult ;
82061   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82062   int arg2 ;
82063   Dali::Actor *result = 0 ;
82064
82065   arg1 = (std::vector< Dali::Actor > *)jarg1;
82066   arg2 = (int)jarg2;
82067   {
82068     try {
82069       try {
82070         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
82071       }
82072       catch(std::out_of_range &_e) {
82073         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82074         return 0;
82075       }
82076
82077     } catch (std::out_of_range& e) {
82078       {
82079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82080       };
82081     } catch (std::exception& e) {
82082       {
82083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82084       };
82085     } catch (...) {
82086       {
82087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82088       };
82089     }
82090   }
82091   jresult = (void *)result;
82092   return jresult;
82093 }
82094
82095
82096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
82097   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82098   int arg2 ;
82099   Dali::Actor *arg3 = 0 ;
82100
82101   arg1 = (std::vector< Dali::Actor > *)jarg1;
82102   arg2 = (int)jarg2;
82103   arg3 = (Dali::Actor *)jarg3;
82104   if (!arg3) {
82105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
82106     return ;
82107   }
82108   {
82109     try {
82110       try {
82111         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
82112       }
82113       catch(std::out_of_range &_e) {
82114         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82115         return ;
82116       }
82117
82118     } catch (std::out_of_range& e) {
82119       {
82120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82121       };
82122     } catch (std::exception& e) {
82123       {
82124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82125       };
82126     } catch (...) {
82127       {
82128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82129       };
82130     }
82131   }
82132 }
82133
82134
82135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
82136   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82137   std::vector< Dali::Actor > *arg2 = 0 ;
82138
82139   arg1 = (std::vector< Dali::Actor > *)jarg1;
82140   arg2 = (std::vector< Dali::Actor > *)jarg2;
82141   if (!arg2) {
82142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
82143     return ;
82144   }
82145   {
82146     try {
82147       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
82148     } catch (std::out_of_range& e) {
82149       {
82150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82151       };
82152     } catch (std::exception& e) {
82153       {
82154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82155       };
82156     } catch (...) {
82157       {
82158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82159       };
82160     }
82161   }
82162 }
82163
82164
82165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
82166   void * jresult ;
82167   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82168   int arg2 ;
82169   int arg3 ;
82170   std::vector< Dali::Actor > *result = 0 ;
82171
82172   arg1 = (std::vector< Dali::Actor > *)jarg1;
82173   arg2 = (int)jarg2;
82174   arg3 = (int)jarg3;
82175   {
82176     try {
82177       try {
82178         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
82179       }
82180       catch(std::out_of_range &_e) {
82181         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82182         return 0;
82183       }
82184       catch(std::invalid_argument &_e) {
82185         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
82186         return 0;
82187       }
82188
82189     } catch (std::out_of_range& e) {
82190       {
82191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82192       };
82193     } catch (std::exception& e) {
82194       {
82195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82196       };
82197     } catch (...) {
82198       {
82199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82200       };
82201     }
82202   }
82203   jresult = (void *)result;
82204   return jresult;
82205 }
82206
82207
82208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
82209   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82210   int arg2 ;
82211   Dali::Actor *arg3 = 0 ;
82212
82213   arg1 = (std::vector< Dali::Actor > *)jarg1;
82214   arg2 = (int)jarg2;
82215   arg3 = (Dali::Actor *)jarg3;
82216   if (!arg3) {
82217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
82218     return ;
82219   }
82220   {
82221     try {
82222       try {
82223         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
82224       }
82225       catch(std::out_of_range &_e) {
82226         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82227         return ;
82228       }
82229
82230     } catch (std::out_of_range& e) {
82231       {
82232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82233       };
82234     } catch (std::exception& e) {
82235       {
82236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82237       };
82238     } catch (...) {
82239       {
82240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82241       };
82242     }
82243   }
82244 }
82245
82246
82247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
82248   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82249   int arg2 ;
82250   std::vector< Dali::Actor > *arg3 = 0 ;
82251
82252   arg1 = (std::vector< Dali::Actor > *)jarg1;
82253   arg2 = (int)jarg2;
82254   arg3 = (std::vector< Dali::Actor > *)jarg3;
82255   if (!arg3) {
82256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
82257     return ;
82258   }
82259   {
82260     try {
82261       try {
82262         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
82263       }
82264       catch(std::out_of_range &_e) {
82265         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82266         return ;
82267       }
82268
82269     } catch (std::out_of_range& e) {
82270       {
82271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82272       };
82273     } catch (std::exception& e) {
82274       {
82275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82276       };
82277     } catch (...) {
82278       {
82279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82280       };
82281     }
82282   }
82283 }
82284
82285
82286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
82287   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82288   int arg2 ;
82289
82290   arg1 = (std::vector< Dali::Actor > *)jarg1;
82291   arg2 = (int)jarg2;
82292   {
82293     try {
82294       try {
82295         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
82296       }
82297       catch(std::out_of_range &_e) {
82298         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82299         return ;
82300       }
82301
82302     } catch (std::out_of_range& e) {
82303       {
82304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82305       };
82306     } catch (std::exception& e) {
82307       {
82308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82309       };
82310     } catch (...) {
82311       {
82312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82313       };
82314     }
82315   }
82316 }
82317
82318
82319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
82320   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82321   int arg2 ;
82322   int arg3 ;
82323
82324   arg1 = (std::vector< Dali::Actor > *)jarg1;
82325   arg2 = (int)jarg2;
82326   arg3 = (int)jarg3;
82327   {
82328     try {
82329       try {
82330         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
82331       }
82332       catch(std::out_of_range &_e) {
82333         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82334         return ;
82335       }
82336       catch(std::invalid_argument &_e) {
82337         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
82338         return ;
82339       }
82340
82341     } catch (std::out_of_range& e) {
82342       {
82343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82344       };
82345     } catch (std::exception& e) {
82346       {
82347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82348       };
82349     } catch (...) {
82350       {
82351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82352       };
82353     }
82354   }
82355 }
82356
82357
82358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
82359   void * jresult ;
82360   Dali::Actor *arg1 = 0 ;
82361   int arg2 ;
82362   std::vector< Dali::Actor > *result = 0 ;
82363
82364   arg1 = (Dali::Actor *)jarg1;
82365   if (!arg1) {
82366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
82367     return 0;
82368   }
82369   arg2 = (int)jarg2;
82370   {
82371     try {
82372       try {
82373         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
82374       }
82375       catch(std::out_of_range &_e) {
82376         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82377         return 0;
82378       }
82379
82380     } catch (std::out_of_range& e) {
82381       {
82382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82383       };
82384     } catch (std::exception& e) {
82385       {
82386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82387       };
82388     } catch (...) {
82389       {
82390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82391       };
82392     }
82393   }
82394   jresult = (void *)result;
82395   return jresult;
82396 }
82397
82398
82399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
82400   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82401
82402   arg1 = (std::vector< Dali::Actor > *)jarg1;
82403   {
82404     try {
82405       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
82406     } catch (std::out_of_range& e) {
82407       {
82408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82409       };
82410     } catch (std::exception& e) {
82411       {
82412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82413       };
82414     } catch (...) {
82415       {
82416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82417       };
82418     }
82419   }
82420 }
82421
82422
82423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
82424   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82425   int arg2 ;
82426   int arg3 ;
82427
82428   arg1 = (std::vector< Dali::Actor > *)jarg1;
82429   arg2 = (int)jarg2;
82430   arg3 = (int)jarg3;
82431   {
82432     try {
82433       try {
82434         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
82435       }
82436       catch(std::out_of_range &_e) {
82437         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82438         return ;
82439       }
82440       catch(std::invalid_argument &_e) {
82441         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
82442         return ;
82443       }
82444
82445     } catch (std::out_of_range& e) {
82446       {
82447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82448       };
82449     } catch (std::exception& e) {
82450       {
82451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82452       };
82453     } catch (...) {
82454       {
82455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82456       };
82457     }
82458   }
82459 }
82460
82461
82462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
82463   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82464   int arg2 ;
82465   std::vector< Dali::Actor > *arg3 = 0 ;
82466
82467   arg1 = (std::vector< Dali::Actor > *)jarg1;
82468   arg2 = (int)jarg2;
82469   arg3 = (std::vector< Dali::Actor > *)jarg3;
82470   if (!arg3) {
82471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
82472     return ;
82473   }
82474   {
82475     try {
82476       try {
82477         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
82478       }
82479       catch(std::out_of_range &_e) {
82480         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82481         return ;
82482       }
82483
82484     } catch (std::out_of_range& e) {
82485       {
82486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82487       };
82488     } catch (std::exception& e) {
82489       {
82490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82491       };
82492     } catch (...) {
82493       {
82494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82495       };
82496     }
82497   }
82498 }
82499
82500
82501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
82502   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82503
82504   arg1 = (std::vector< Dali::Actor > *)jarg1;
82505   {
82506     try {
82507       delete arg1;
82508     } catch (std::out_of_range& e) {
82509       {
82510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82511       };
82512     } catch (std::exception& e) {
82513       {
82514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82515       };
82516     } catch (...) {
82517       {
82518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82519       };
82520     }
82521   }
82522 }
82523
82524
82525 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
82526   unsigned int jresult ;
82527   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82528   bool result;
82529
82530   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82531   {
82532     try {
82533       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
82534     } catch (std::out_of_range& e) {
82535       {
82536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82537       };
82538     } catch (std::exception& e) {
82539       {
82540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82541       };
82542     } catch (...) {
82543       {
82544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82545       };
82546     }
82547   }
82548   jresult = result;
82549   return jresult;
82550 }
82551
82552
82553 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
82554   unsigned long jresult ;
82555   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82556   std::size_t result;
82557
82558   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82559   {
82560     try {
82561       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
82562     } catch (std::out_of_range& e) {
82563       {
82564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82565       };
82566     } catch (std::exception& e) {
82567       {
82568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82569       };
82570     } catch (...) {
82571       {
82572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82573       };
82574     }
82575   }
82576   jresult = (unsigned long)result;
82577   return jresult;
82578 }
82579
82580
82581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
82582   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82583   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
82584
82585   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82586   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
82587   {
82588     try {
82589       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
82590     } catch (std::out_of_range& e) {
82591       {
82592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82593       };
82594     } catch (std::exception& e) {
82595       {
82596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82597       };
82598     } catch (...) {
82599       {
82600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82601       };
82602     }
82603   }
82604 }
82605
82606
82607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
82608   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82609   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
82610
82611   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82612   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
82613   {
82614     try {
82615       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
82616     } catch (std::out_of_range& e) {
82617       {
82618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82619       };
82620     } catch (std::exception& e) {
82621       {
82622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82623       };
82624     } catch (...) {
82625       {
82626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82627       };
82628     }
82629   }
82630 }
82631
82632
82633 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
82634   unsigned int jresult ;
82635   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82636   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
82637   bool result;
82638
82639   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82640   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
82641   if (!arg2) {
82642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
82643     return 0;
82644   }
82645   {
82646     try {
82647       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
82648     } catch (std::out_of_range& e) {
82649       {
82650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82651       };
82652     } catch (std::exception& e) {
82653       {
82654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82655       };
82656     } catch (...) {
82657       {
82658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82659       };
82660     }
82661   }
82662   jresult = result;
82663   return jresult;
82664 }
82665
82666
82667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
82668   void * jresult ;
82669   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
82670
82671   {
82672     try {
82673       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
82674     } catch (std::out_of_range& e) {
82675       {
82676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82677       };
82678     } catch (std::exception& e) {
82679       {
82680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82681       };
82682     } catch (...) {
82683       {
82684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82685       };
82686     }
82687   }
82688   jresult = (void *)result;
82689   return jresult;
82690 }
82691
82692
82693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
82694   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82695
82696   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82697   {
82698     try {
82699       delete arg1;
82700     } catch (std::out_of_range& e) {
82701       {
82702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82703       };
82704     } catch (std::exception& e) {
82705       {
82706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82707       };
82708     } catch (...) {
82709       {
82710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82711       };
82712     }
82713   }
82714 }
82715
82716
82717 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
82718   unsigned int jresult ;
82719   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
82720   bool result;
82721
82722   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
82723   {
82724     try {
82725       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);
82726     } catch (std::out_of_range& e) {
82727       {
82728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82729       };
82730     } catch (std::exception& e) {
82731       {
82732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82733       };
82734     } catch (...) {
82735       {
82736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82737       };
82738     }
82739   }
82740   jresult = result;
82741   return jresult;
82742 }
82743
82744
82745 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
82746   unsigned long jresult ;
82747   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
82748   std::size_t result;
82749
82750   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
82751   {
82752     try {
82753       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);
82754     } catch (std::out_of_range& e) {
82755       {
82756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82757       };
82758     } catch (std::exception& e) {
82759       {
82760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82761       };
82762     } catch (...) {
82763       {
82764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82765       };
82766     }
82767   }
82768   jresult = (unsigned long)result;
82769   return jresult;
82770 }
82771
82772
82773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
82774   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
82775   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
82776
82777   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
82778   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
82779   {
82780     try {
82781       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
82782     } catch (std::out_of_range& e) {
82783       {
82784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82785       };
82786     } catch (std::exception& e) {
82787       {
82788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82789       };
82790     } catch (...) {
82791       {
82792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82793       };
82794     }
82795   }
82796 }
82797
82798
82799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
82800   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
82801   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
82802
82803   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
82804   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
82805   {
82806     try {
82807       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
82808     } catch (std::out_of_range& e) {
82809       {
82810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82811       };
82812     } catch (std::exception& e) {
82813       {
82814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82815       };
82816     } catch (...) {
82817       {
82818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82819       };
82820     }
82821   }
82822 }
82823
82824
82825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
82826   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
82827   Dali::Actor arg2 ;
82828   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
82829   Dali::Actor *argp2 ;
82830
82831   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
82832   argp2 = (Dali::Actor *)jarg2;
82833   if (!argp2) {
82834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82835     return ;
82836   }
82837   arg2 = *argp2;
82838   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
82839   {
82840     try {
82841       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
82842     } catch (std::out_of_range& e) {
82843       {
82844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82845       };
82846     } catch (std::exception& e) {
82847       {
82848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82849       };
82850     } catch (...) {
82851       {
82852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82853       };
82854     }
82855   }
82856 }
82857
82858
82859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
82860   void * jresult ;
82861   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
82862
82863   {
82864     try {
82865       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
82866     } catch (std::out_of_range& e) {
82867       {
82868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82869       };
82870     } catch (std::exception& e) {
82871       {
82872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82873       };
82874     } catch (...) {
82875       {
82876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82877       };
82878     }
82879   }
82880   jresult = (void *)result;
82881   return jresult;
82882 }
82883
82884
82885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
82886   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
82887
82888   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
82889   {
82890     try {
82891       delete arg1;
82892     } catch (std::out_of_range& e) {
82893       {
82894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82895       };
82896     } catch (std::exception& e) {
82897       {
82898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82899       };
82900     } catch (...) {
82901       {
82902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82903       };
82904     }
82905   }
82906 }
82907
82908
82909 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
82910   unsigned int jresult ;
82911   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
82912   bool result;
82913
82914   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
82915   {
82916     try {
82917       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
82918     } catch (std::out_of_range& e) {
82919       {
82920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82921       };
82922     } catch (std::exception& e) {
82923       {
82924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82925       };
82926     } catch (...) {
82927       {
82928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82929       };
82930     }
82931   }
82932   jresult = result;
82933   return jresult;
82934 }
82935
82936
82937 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
82938   unsigned long jresult ;
82939   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
82940   std::size_t result;
82941
82942   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
82943   {
82944     try {
82945       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
82946     } catch (std::out_of_range& e) {
82947       {
82948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82949       };
82950     } catch (std::exception& e) {
82951       {
82952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82953       };
82954     } catch (...) {
82955       {
82956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82957       };
82958     }
82959   }
82960   jresult = (unsigned long)result;
82961   return jresult;
82962 }
82963
82964
82965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
82966   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
82967   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
82968
82969   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
82970   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
82971   {
82972     try {
82973       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
82974     } catch (std::out_of_range& e) {
82975       {
82976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82977       };
82978     } catch (std::exception& e) {
82979       {
82980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82981       };
82982     } catch (...) {
82983       {
82984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82985       };
82986     }
82987   }
82988 }
82989
82990
82991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
82992   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
82993   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
82994
82995   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
82996   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
82997   {
82998     try {
82999       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
83000     } catch (std::out_of_range& e) {
83001       {
83002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83003       };
83004     } catch (std::exception& e) {
83005       {
83006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83007       };
83008     } catch (...) {
83009       {
83010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83011       };
83012     }
83013   }
83014 }
83015
83016
83017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
83018   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
83019   Dali::Actor arg2 ;
83020   Dali::Actor arg3 ;
83021   Dali::Actor *argp2 ;
83022   Dali::Actor *argp3 ;
83023
83024   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
83025   argp2 = (Dali::Actor *)jarg2;
83026   if (!argp2) {
83027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83028     return ;
83029   }
83030   arg2 = *argp2;
83031   argp3 = (Dali::Actor *)jarg3;
83032   if (!argp3) {
83033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83034     return ;
83035   }
83036   arg3 = *argp3;
83037   {
83038     try {
83039       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
83040     } catch (std::out_of_range& e) {
83041       {
83042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83043       };
83044     } catch (std::exception& e) {
83045       {
83046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83047       };
83048     } catch (...) {
83049       {
83050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83051       };
83052     }
83053   }
83054 }
83055
83056
83057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
83058   void * jresult ;
83059   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
83060
83061   {
83062     try {
83063       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
83064     } catch (std::out_of_range& e) {
83065       {
83066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83067       };
83068     } catch (std::exception& e) {
83069       {
83070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83071       };
83072     } catch (...) {
83073       {
83074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83075       };
83076     }
83077   }
83078   jresult = (void *)result;
83079   return jresult;
83080 }
83081
83082
83083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
83084   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
83085
83086   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
83087   {
83088     try {
83089       delete arg1;
83090     } catch (std::out_of_range& e) {
83091       {
83092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83093       };
83094     } catch (std::exception& e) {
83095       {
83096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83097       };
83098     } catch (...) {
83099       {
83100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83101       };
83102     }
83103   }
83104 }
83105
83106
83107 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
83108   unsigned int jresult ;
83109   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83110   bool result;
83111
83112   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83113   {
83114     try {
83115       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
83116     } catch (std::out_of_range& e) {
83117       {
83118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83119       };
83120     } catch (std::exception& e) {
83121       {
83122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83123       };
83124     } catch (...) {
83125       {
83126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83127       };
83128     }
83129   }
83130   jresult = result;
83131   return jresult;
83132 }
83133
83134
83135 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
83136   unsigned long jresult ;
83137   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83138   std::size_t result;
83139
83140   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83141   {
83142     try {
83143       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
83144     } catch (std::out_of_range& e) {
83145       {
83146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83147       };
83148     } catch (std::exception& e) {
83149       {
83150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83151       };
83152     } catch (...) {
83153       {
83154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83155       };
83156     }
83157   }
83158   jresult = (unsigned long)result;
83159   return jresult;
83160 }
83161
83162
83163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
83164   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83165   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
83166
83167   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83168   arg2 = (void (*)(Dali::Actor,bool))jarg2;
83169   {
83170     try {
83171       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
83172     } catch (std::out_of_range& e) {
83173       {
83174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83175       };
83176     } catch (std::exception& e) {
83177       {
83178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83179       };
83180     } catch (...) {
83181       {
83182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83183       };
83184     }
83185   }
83186 }
83187
83188
83189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
83190   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83191   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
83192
83193   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83194   arg2 = (void (*)(Dali::Actor,bool))jarg2;
83195   {
83196     try {
83197       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
83198     } catch (std::out_of_range& e) {
83199       {
83200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83201       };
83202     } catch (std::exception& e) {
83203       {
83204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83205       };
83206     } catch (...) {
83207       {
83208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83209       };
83210     }
83211   }
83212 }
83213
83214
83215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
83216   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83217   Dali::Actor arg2 ;
83218   bool arg3 ;
83219   Dali::Actor *argp2 ;
83220
83221   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83222   argp2 = (Dali::Actor *)jarg2;
83223   if (!argp2) {
83224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83225     return ;
83226   }
83227   arg2 = *argp2;
83228   arg3 = jarg3 ? true : false;
83229   {
83230     try {
83231       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
83232     } catch (std::out_of_range& e) {
83233       {
83234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83235       };
83236     } catch (std::exception& e) {
83237       {
83238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83239       };
83240     } catch (...) {
83241       {
83242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83243       };
83244     }
83245   }
83246 }
83247
83248
83249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
83250   void * jresult ;
83251   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
83252
83253   {
83254     try {
83255       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
83256     } catch (std::out_of_range& e) {
83257       {
83258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83259       };
83260     } catch (std::exception& e) {
83261       {
83262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83263       };
83264     } catch (...) {
83265       {
83266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83267       };
83268     }
83269   }
83270   jresult = (void *)result;
83271   return jresult;
83272 }
83273
83274
83275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
83276   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83277
83278   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83279   {
83280     try {
83281       delete arg1;
83282     } catch (std::out_of_range& e) {
83283       {
83284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83285       };
83286     } catch (std::exception& e) {
83287       {
83288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83289       };
83290     } catch (...) {
83291       {
83292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83293       };
83294     }
83295   }
83296 }
83297
83298
83299 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
83300   unsigned int jresult ;
83301   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83302   bool result;
83303
83304   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83305   {
83306     try {
83307       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);
83308     } catch (std::out_of_range& e) {
83309       {
83310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83311       };
83312     } catch (std::exception& e) {
83313       {
83314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83315       };
83316     } catch (...) {
83317       {
83318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83319       };
83320     }
83321   }
83322   jresult = result;
83323   return jresult;
83324 }
83325
83326
83327 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
83328   unsigned long jresult ;
83329   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83330   std::size_t result;
83331
83332   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83333   {
83334     try {
83335       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);
83336     } catch (std::out_of_range& e) {
83337       {
83338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83339       };
83340     } catch (std::exception& e) {
83341       {
83342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83343       };
83344     } catch (...) {
83345       {
83346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83347       };
83348     }
83349   }
83350   jresult = (unsigned long)result;
83351   return jresult;
83352 }
83353
83354
83355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
83356   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83357   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
83358
83359   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83360   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
83361   {
83362     try {
83363       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
83364     } catch (std::out_of_range& e) {
83365       {
83366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83367       };
83368     } catch (std::exception& e) {
83369       {
83370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83371       };
83372     } catch (...) {
83373       {
83374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83375       };
83376     }
83377   }
83378 }
83379
83380
83381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
83382   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83383   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
83384
83385   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83386   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
83387   {
83388     try {
83389       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
83390     } catch (std::out_of_range& e) {
83391       {
83392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83393       };
83394     } catch (std::exception& e) {
83395       {
83396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83397       };
83398     } catch (...) {
83399       {
83400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83401       };
83402     }
83403   }
83404 }
83405
83406
83407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
83408   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83409   Dali::Toolkit::StyleManager arg2 ;
83410   Dali::StyleChange::Type arg3 ;
83411   Dali::Toolkit::StyleManager *argp2 ;
83412
83413   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83414   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
83415   if (!argp2) {
83416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
83417     return ;
83418   }
83419   arg2 = *argp2;
83420   arg3 = (Dali::StyleChange::Type)jarg3;
83421   {
83422     try {
83423       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
83424     } catch (std::out_of_range& e) {
83425       {
83426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83427       };
83428     } catch (std::exception& e) {
83429       {
83430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83431       };
83432     } catch (...) {
83433       {
83434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83435       };
83436     }
83437   }
83438 }
83439
83440
83441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
83442   void * jresult ;
83443   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
83444
83445   {
83446     try {
83447       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
83448     } catch (std::out_of_range& e) {
83449       {
83450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83451       };
83452     } catch (std::exception& e) {
83453       {
83454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83455       };
83456     } catch (...) {
83457       {
83458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83459       };
83460     }
83461   }
83462   jresult = (void *)result;
83463   return jresult;
83464 }
83465
83466
83467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
83468   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83469
83470   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83471   {
83472     try {
83473       delete arg1;
83474     } catch (std::out_of_range& e) {
83475       {
83476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83477       };
83478     } catch (std::exception& e) {
83479       {
83480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83481       };
83482     } catch (...) {
83483       {
83484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83485       };
83486     }
83487   }
83488 }
83489
83490
83491 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
83492   unsigned int jresult ;
83493   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83494   bool result;
83495
83496   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83497   {
83498     try {
83499       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
83500     } catch (std::out_of_range& e) {
83501       {
83502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83503       };
83504     } catch (std::exception& e) {
83505       {
83506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83507       };
83508     } catch (...) {
83509       {
83510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83511       };
83512     }
83513   }
83514   jresult = result;
83515   return jresult;
83516 }
83517
83518
83519 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
83520   unsigned long jresult ;
83521   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83522   std::size_t result;
83523
83524   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83525   {
83526     try {
83527       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
83528     } catch (std::out_of_range& e) {
83529       {
83530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83531       };
83532     } catch (std::exception& e) {
83533       {
83534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83535       };
83536     } catch (...) {
83537       {
83538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83539       };
83540     }
83541   }
83542   jresult = (unsigned long)result;
83543   return jresult;
83544 }
83545
83546
83547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
83548   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83549   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
83550
83551   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83552   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
83553   {
83554     try {
83555       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
83556     } catch (std::out_of_range& e) {
83557       {
83558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83559       };
83560     } catch (std::exception& e) {
83561       {
83562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83563       };
83564     } catch (...) {
83565       {
83566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83567       };
83568     }
83569   }
83570 }
83571
83572
83573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
83574   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83575   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
83576
83577   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83578   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
83579   {
83580     try {
83581       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
83582     } catch (std::out_of_range& e) {
83583       {
83584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83585       };
83586     } catch (std::exception& e) {
83587       {
83588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83589       };
83590     } catch (...) {
83591       {
83592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83593       };
83594     }
83595   }
83596 }
83597
83598
83599 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
83600   unsigned int jresult ;
83601   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83602   Dali::Toolkit::Button arg2 ;
83603   Dali::Toolkit::Button *argp2 ;
83604   bool result;
83605
83606   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83607   argp2 = (Dali::Toolkit::Button *)jarg2;
83608   if (!argp2) {
83609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
83610     return 0;
83611   }
83612   arg2 = *argp2;
83613   {
83614     try {
83615       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
83616     } catch (std::out_of_range& e) {
83617       {
83618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83619       };
83620     } catch (std::exception& e) {
83621       {
83622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83623       };
83624     } catch (...) {
83625       {
83626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83627       };
83628     }
83629   }
83630   jresult = result;
83631   return jresult;
83632 }
83633
83634
83635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
83636   void * jresult ;
83637   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
83638
83639   {
83640     try {
83641       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
83642     } catch (std::out_of_range& e) {
83643       {
83644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83645       };
83646     } catch (std::exception& e) {
83647       {
83648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83649       };
83650     } catch (...) {
83651       {
83652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83653       };
83654     }
83655   }
83656   jresult = (void *)result;
83657   return jresult;
83658 }
83659
83660
83661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
83662   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83663
83664   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83665   {
83666     try {
83667       delete arg1;
83668     } catch (std::out_of_range& e) {
83669       {
83670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83671       };
83672     } catch (std::exception& e) {
83673       {
83674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83675       };
83676     } catch (...) {
83677       {
83678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83679       };
83680     }
83681   }
83682 }
83683
83684
83685 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
83686   unsigned int jresult ;
83687   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
83688   bool result;
83689
83690   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
83691   {
83692     try {
83693       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
83694     } catch (std::out_of_range& e) {
83695       {
83696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83697       };
83698     } catch (std::exception& e) {
83699       {
83700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83701       };
83702     } catch (...) {
83703       {
83704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83705       };
83706     }
83707   }
83708   jresult = result;
83709   return jresult;
83710 }
83711
83712
83713 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
83714   unsigned long jresult ;
83715   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
83716   std::size_t result;
83717
83718   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
83719   {
83720     try {
83721       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
83722     } catch (std::out_of_range& e) {
83723       {
83724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83725       };
83726     } catch (std::exception& e) {
83727       {
83728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83729       };
83730     } catch (...) {
83731       {
83732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83733       };
83734     }
83735   }
83736   jresult = (unsigned long)result;
83737   return jresult;
83738 }
83739
83740
83741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
83742   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
83743   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
83744
83745   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
83746   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
83747   {
83748     try {
83749       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
83750     } catch (std::out_of_range& e) {
83751       {
83752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83753       };
83754     } catch (std::exception& e) {
83755       {
83756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83757       };
83758     } catch (...) {
83759       {
83760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83761       };
83762     }
83763   }
83764 }
83765
83766
83767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
83768   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
83769   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
83770
83771   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
83772   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
83773   {
83774     try {
83775       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
83776     } catch (std::out_of_range& e) {
83777       {
83778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83779       };
83780     } catch (std::exception& e) {
83781       {
83782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83783       };
83784     } catch (...) {
83785       {
83786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83787       };
83788     }
83789   }
83790 }
83791
83792
83793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
83794   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
83795   Dali::Toolkit::GaussianBlurView arg2 ;
83796   Dali::Toolkit::GaussianBlurView *argp2 ;
83797
83798   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
83799   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
83800   if (!argp2) {
83801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
83802     return ;
83803   }
83804   arg2 = *argp2;
83805   {
83806     try {
83807       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
83808     } catch (std::out_of_range& e) {
83809       {
83810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83811       };
83812     } catch (std::exception& e) {
83813       {
83814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83815       };
83816     } catch (...) {
83817       {
83818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83819       };
83820     }
83821   }
83822 }
83823
83824
83825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
83826   void * jresult ;
83827   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
83828
83829   {
83830     try {
83831       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
83832     } catch (std::out_of_range& e) {
83833       {
83834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83835       };
83836     } catch (std::exception& e) {
83837       {
83838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83839       };
83840     } catch (...) {
83841       {
83842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83843       };
83844     }
83845   }
83846   jresult = (void *)result;
83847   return jresult;
83848 }
83849
83850
83851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
83852   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
83853
83854   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
83855   {
83856     try {
83857       delete arg1;
83858     } catch (std::out_of_range& e) {
83859       {
83860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83861       };
83862     } catch (std::exception& e) {
83863       {
83864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83865       };
83866     } catch (...) {
83867       {
83868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83869       };
83870     }
83871   }
83872 }
83873
83874
83875 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
83876   unsigned int jresult ;
83877   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
83878   bool result;
83879
83880   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
83881   {
83882     try {
83883       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);
83884     } catch (std::out_of_range& e) {
83885       {
83886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83887       };
83888     } catch (std::exception& e) {
83889       {
83890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83891       };
83892     } catch (...) {
83893       {
83894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83895       };
83896     }
83897   }
83898   jresult = result;
83899   return jresult;
83900 }
83901
83902
83903 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
83904   unsigned long jresult ;
83905   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
83906   std::size_t result;
83907
83908   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
83909   {
83910     try {
83911       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);
83912     } catch (std::out_of_range& e) {
83913       {
83914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83915       };
83916     } catch (std::exception& e) {
83917       {
83918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83919       };
83920     } catch (...) {
83921       {
83922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83923       };
83924     }
83925   }
83926   jresult = (unsigned long)result;
83927   return jresult;
83928 }
83929
83930
83931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
83932   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
83933   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
83934
83935   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
83936   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
83937   {
83938     try {
83939       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
83940     } catch (std::out_of_range& e) {
83941       {
83942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83943       };
83944     } catch (std::exception& e) {
83945       {
83946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83947       };
83948     } catch (...) {
83949       {
83950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83951       };
83952     }
83953   }
83954 }
83955
83956
83957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
83958   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
83959   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
83960
83961   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
83962   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
83963   {
83964     try {
83965       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
83966     } catch (std::out_of_range& e) {
83967       {
83968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83969       };
83970     } catch (std::exception& e) {
83971       {
83972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83973       };
83974     } catch (...) {
83975       {
83976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83977       };
83978     }
83979   }
83980 }
83981
83982
83983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
83984   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
83985   Dali::Toolkit::PageTurnView arg2 ;
83986   unsigned int arg3 ;
83987   bool arg4 ;
83988   Dali::Toolkit::PageTurnView *argp2 ;
83989
83990   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
83991   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
83992   if (!argp2) {
83993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
83994     return ;
83995   }
83996   arg2 = *argp2;
83997   arg3 = (unsigned int)jarg3;
83998   arg4 = jarg4 ? true : false;
83999   {
84000     try {
84001       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
84002     } catch (std::out_of_range& e) {
84003       {
84004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84005       };
84006     } catch (std::exception& e) {
84007       {
84008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84009       };
84010     } catch (...) {
84011       {
84012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84013       };
84014     }
84015   }
84016 }
84017
84018
84019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
84020   void * jresult ;
84021   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
84022
84023   {
84024     try {
84025       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
84026     } catch (std::out_of_range& e) {
84027       {
84028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84029       };
84030     } catch (std::exception& e) {
84031       {
84032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84033       };
84034     } catch (...) {
84035       {
84036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84037       };
84038     }
84039   }
84040   jresult = (void *)result;
84041   return jresult;
84042 }
84043
84044
84045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
84046   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
84047
84048   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
84049   {
84050     try {
84051       delete arg1;
84052     } catch (std::out_of_range& e) {
84053       {
84054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84055       };
84056     } catch (std::exception& e) {
84057       {
84058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84059       };
84060     } catch (...) {
84061       {
84062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84063       };
84064     }
84065   }
84066 }
84067
84068
84069 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
84070   unsigned int jresult ;
84071   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84072   bool result;
84073
84074   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84075   {
84076     try {
84077       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
84078     } catch (std::out_of_range& e) {
84079       {
84080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84081       };
84082     } catch (std::exception& e) {
84083       {
84084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84085       };
84086     } catch (...) {
84087       {
84088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84089       };
84090     }
84091   }
84092   jresult = result;
84093   return jresult;
84094 }
84095
84096
84097 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
84098   unsigned long jresult ;
84099   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84100   std::size_t result;
84101
84102   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84103   {
84104     try {
84105       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
84106     } catch (std::out_of_range& e) {
84107       {
84108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84109       };
84110     } catch (std::exception& e) {
84111       {
84112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84113       };
84114     } catch (...) {
84115       {
84116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84117       };
84118     }
84119   }
84120   jresult = (unsigned long)result;
84121   return jresult;
84122 }
84123
84124
84125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
84126   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84127   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
84128
84129   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84130   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
84131   {
84132     try {
84133       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
84134     } catch (std::out_of_range& e) {
84135       {
84136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84137       };
84138     } catch (std::exception& e) {
84139       {
84140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84141       };
84142     } catch (...) {
84143       {
84144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84145       };
84146     }
84147   }
84148 }
84149
84150
84151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
84152   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84153   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
84154
84155   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84156   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
84157   {
84158     try {
84159       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
84160     } catch (std::out_of_range& e) {
84161       {
84162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84163       };
84164     } catch (std::exception& e) {
84165       {
84166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84167       };
84168     } catch (...) {
84169       {
84170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84171       };
84172     }
84173   }
84174 }
84175
84176
84177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
84178   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84179   Dali::Toolkit::PageTurnView arg2 ;
84180   Dali::Toolkit::PageTurnView *argp2 ;
84181
84182   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84183   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
84184   if (!argp2) {
84185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
84186     return ;
84187   }
84188   arg2 = *argp2;
84189   {
84190     try {
84191       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
84192     } catch (std::out_of_range& e) {
84193       {
84194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84195       };
84196     } catch (std::exception& e) {
84197       {
84198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84199       };
84200     } catch (...) {
84201       {
84202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84203       };
84204     }
84205   }
84206 }
84207
84208
84209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
84210   void * jresult ;
84211   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
84212
84213   {
84214     try {
84215       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
84216     } catch (std::out_of_range& e) {
84217       {
84218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84219       };
84220     } catch (std::exception& e) {
84221       {
84222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84223       };
84224     } catch (...) {
84225       {
84226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84227       };
84228     }
84229   }
84230   jresult = (void *)result;
84231   return jresult;
84232 }
84233
84234
84235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
84236   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84237
84238   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84239   {
84240     try {
84241       delete arg1;
84242     } catch (std::out_of_range& e) {
84243       {
84244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84245       };
84246     } catch (std::exception& e) {
84247       {
84248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84249       };
84250     } catch (...) {
84251       {
84252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84253       };
84254     }
84255   }
84256 }
84257
84258
84259 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
84260   unsigned int jresult ;
84261   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84262   bool result;
84263
84264   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84265   {
84266     try {
84267       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);
84268     } catch (std::out_of_range& e) {
84269       {
84270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84271       };
84272     } catch (std::exception& e) {
84273       {
84274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84275       };
84276     } catch (...) {
84277       {
84278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84279       };
84280     }
84281   }
84282   jresult = result;
84283   return jresult;
84284 }
84285
84286
84287 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
84288   unsigned long jresult ;
84289   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84290   std::size_t result;
84291
84292   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84293   {
84294     try {
84295       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);
84296     } catch (std::out_of_range& e) {
84297       {
84298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84299       };
84300     } catch (std::exception& e) {
84301       {
84302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84303       };
84304     } catch (...) {
84305       {
84306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84307       };
84308     }
84309   }
84310   jresult = (unsigned long)result;
84311   return jresult;
84312 }
84313
84314
84315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
84316   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84317   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
84318
84319   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84320   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
84321   {
84322     try {
84323       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
84324     } catch (std::out_of_range& e) {
84325       {
84326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84327       };
84328     } catch (std::exception& e) {
84329       {
84330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84331       };
84332     } catch (...) {
84333       {
84334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84335       };
84336     }
84337   }
84338 }
84339
84340
84341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
84342   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84343   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
84344
84345   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84346   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
84347   {
84348     try {
84349       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
84350     } catch (std::out_of_range& e) {
84351       {
84352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84353       };
84354     } catch (std::exception& e) {
84355       {
84356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84357       };
84358     } catch (...) {
84359       {
84360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84361       };
84362     }
84363   }
84364 }
84365
84366
84367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
84368   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84369   Dali::Toolkit::ProgressBar arg2 ;
84370   float arg3 ;
84371   float arg4 ;
84372   Dali::Toolkit::ProgressBar *argp2 ;
84373
84374   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84375   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
84376   if (!argp2) {
84377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
84378     return ;
84379   }
84380   arg2 = *argp2;
84381   arg3 = (float)jarg3;
84382   arg4 = (float)jarg4;
84383   {
84384     try {
84385       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
84386     } catch (std::out_of_range& e) {
84387       {
84388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84389       };
84390     } catch (std::exception& e) {
84391       {
84392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84393       };
84394     } catch (...) {
84395       {
84396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84397       };
84398     }
84399   }
84400 }
84401
84402
84403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
84404   void * jresult ;
84405   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
84406
84407   {
84408     try {
84409       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
84410     } catch (std::out_of_range& e) {
84411       {
84412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84413       };
84414     } catch (std::exception& e) {
84415       {
84416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84417       };
84418     } catch (...) {
84419       {
84420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84421       };
84422     }
84423   }
84424   jresult = (void *)result;
84425   return jresult;
84426 }
84427
84428
84429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
84430   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84431
84432   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84433   {
84434     try {
84435       delete arg1;
84436     } catch (std::out_of_range& e) {
84437       {
84438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84439       };
84440     } catch (std::exception& e) {
84441       {
84442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84443       };
84444     } catch (...) {
84445       {
84446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84447       };
84448     }
84449   }
84450 }
84451
84452
84453 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
84454   unsigned int jresult ;
84455   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84456   bool result;
84457
84458   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84459   {
84460     try {
84461       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);
84462     } catch (std::out_of_range& e) {
84463       {
84464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84465       };
84466     } catch (std::exception& e) {
84467       {
84468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84469       };
84470     } catch (...) {
84471       {
84472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84473       };
84474     }
84475   }
84476   jresult = result;
84477   return jresult;
84478 }
84479
84480
84481 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
84482   unsigned long jresult ;
84483   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84484   std::size_t result;
84485
84486   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84487   {
84488     try {
84489       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);
84490     } catch (std::out_of_range& e) {
84491       {
84492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84493       };
84494     } catch (std::exception& e) {
84495       {
84496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84497       };
84498     } catch (...) {
84499       {
84500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84501       };
84502     }
84503   }
84504   jresult = (unsigned long)result;
84505   return jresult;
84506 }
84507
84508
84509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
84510   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84511   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
84512
84513   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84514   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
84515   {
84516     try {
84517       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
84518     } catch (std::out_of_range& e) {
84519       {
84520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84521       };
84522     } catch (std::exception& e) {
84523       {
84524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84525       };
84526     } catch (...) {
84527       {
84528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84529       };
84530     }
84531   }
84532 }
84533
84534
84535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
84536   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84537   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
84538
84539   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84540   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
84541   {
84542     try {
84543       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
84544     } catch (std::out_of_range& e) {
84545       {
84546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84547       };
84548     } catch (std::exception& e) {
84549       {
84550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84551       };
84552     } catch (...) {
84553       {
84554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84555       };
84556     }
84557   }
84558 }
84559
84560
84561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
84562   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84563   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
84564
84565   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84566   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
84567   if (!arg2) {
84568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
84569     return ;
84570   }
84571   {
84572     try {
84573       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
84574     } catch (std::out_of_range& e) {
84575       {
84576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84577       };
84578     } catch (std::exception& e) {
84579       {
84580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84581       };
84582     } catch (...) {
84583       {
84584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84585       };
84586     }
84587   }
84588 }
84589
84590
84591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
84592   void * jresult ;
84593   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
84594
84595   {
84596     try {
84597       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
84598     } catch (std::out_of_range& e) {
84599       {
84600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84601       };
84602     } catch (std::exception& e) {
84603       {
84604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84605       };
84606     } catch (...) {
84607       {
84608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84609       };
84610     }
84611   }
84612   jresult = (void *)result;
84613   return jresult;
84614 }
84615
84616
84617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
84618   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84619
84620   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84621   {
84622     try {
84623       delete arg1;
84624     } catch (std::out_of_range& e) {
84625       {
84626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84627       };
84628     } catch (std::exception& e) {
84629       {
84630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84631       };
84632     } catch (...) {
84633       {
84634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84635       };
84636     }
84637   }
84638 }
84639
84640
84641 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
84642   unsigned int jresult ;
84643   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84644   bool result;
84645
84646   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84647   {
84648     try {
84649       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
84650     } catch (std::out_of_range& e) {
84651       {
84652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84653       };
84654     } catch (std::exception& e) {
84655       {
84656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84657       };
84658     } catch (...) {
84659       {
84660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84661       };
84662     }
84663   }
84664   jresult = result;
84665   return jresult;
84666 }
84667
84668
84669 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
84670   unsigned long jresult ;
84671   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84672   std::size_t result;
84673
84674   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84675   {
84676     try {
84677       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
84678     } catch (std::out_of_range& e) {
84679       {
84680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84681       };
84682     } catch (std::exception& e) {
84683       {
84684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84685       };
84686     } catch (...) {
84687       {
84688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84689       };
84690     }
84691   }
84692   jresult = (unsigned long)result;
84693   return jresult;
84694 }
84695
84696
84697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
84698   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84699   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
84700
84701   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84702   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
84703   {
84704     try {
84705       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
84706     } catch (std::out_of_range& e) {
84707       {
84708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84709       };
84710     } catch (std::exception& e) {
84711       {
84712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84713       };
84714     } catch (...) {
84715       {
84716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84717       };
84718     }
84719   }
84720 }
84721
84722
84723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
84724   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84725   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
84726
84727   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84728   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
84729   {
84730     try {
84731       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
84732     } catch (std::out_of_range& e) {
84733       {
84734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84735       };
84736     } catch (std::exception& e) {
84737       {
84738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84739       };
84740     } catch (...) {
84741       {
84742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84743       };
84744     }
84745   }
84746 }
84747
84748
84749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
84750   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84751   Dali::Vector2 *arg2 = 0 ;
84752
84753   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84754   arg2 = (Dali::Vector2 *)jarg2;
84755   if (!arg2) {
84756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
84757     return ;
84758   }
84759   {
84760     try {
84761       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
84762     } catch (std::out_of_range& e) {
84763       {
84764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84765       };
84766     } catch (std::exception& e) {
84767       {
84768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84769       };
84770     } catch (...) {
84771       {
84772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84773       };
84774     }
84775   }
84776 }
84777
84778
84779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
84780   void * jresult ;
84781   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
84782
84783   {
84784     try {
84785       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
84786     } catch (std::out_of_range& e) {
84787       {
84788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84789       };
84790     } catch (std::exception& e) {
84791       {
84792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84793       };
84794     } catch (...) {
84795       {
84796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84797       };
84798     }
84799   }
84800   jresult = (void *)result;
84801   return jresult;
84802 }
84803
84804
84805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
84806   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84807
84808   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84809   {
84810     try {
84811       delete arg1;
84812     } catch (std::out_of_range& e) {
84813       {
84814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84815       };
84816     } catch (std::exception& e) {
84817       {
84818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84819       };
84820     } catch (...) {
84821       {
84822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84823       };
84824     }
84825   }
84826 }
84827
84828
84829
84830 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
84831   unsigned int jresult ;
84832   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
84833   bool result;
84834
84835   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
84836   {
84837     try {
84838       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);
84839     } catch (std::out_of_range& e) {
84840       {
84841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84842       };
84843     } catch (std::exception& e) {
84844       {
84845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84846       };
84847     } catch (...) {
84848       {
84849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84850       };
84851     }
84852   }
84853   jresult = result;
84854   return jresult;
84855 }
84856
84857
84858 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
84859   unsigned long jresult ;
84860   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
84861   std::size_t result;
84862
84863   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
84864   {
84865     try {
84866       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);
84867     } catch (std::out_of_range& e) {
84868       {
84869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84870       };
84871     } catch (std::exception& e) {
84872       {
84873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84874       };
84875     } catch (...) {
84876       {
84877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84878       };
84879     }
84880   }
84881   jresult = (unsigned long)result;
84882   return jresult;
84883 }
84884
84885
84886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
84887   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
84888   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
84889
84890   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
84891   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
84892   {
84893     try {
84894       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
84895     } catch (std::out_of_range& e) {
84896       {
84897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84898       };
84899     } catch (std::exception& e) {
84900       {
84901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84902       };
84903     } catch (...) {
84904       {
84905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84906       };
84907     }
84908   }
84909 }
84910
84911
84912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
84913   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
84914   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
84915
84916   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
84917   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
84918   {
84919     try {
84920       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
84921     } catch (std::out_of_range& e) {
84922       {
84923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84924       };
84925     } catch (std::exception& e) {
84926       {
84927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84928       };
84929     } catch (...) {
84930       {
84931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84932       };
84933     }
84934   }
84935 }
84936
84937
84938 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
84939   unsigned int jresult ;
84940   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
84941   Dali::Toolkit::Control arg2 ;
84942   Dali::KeyEvent *arg3 = 0 ;
84943   Dali::Toolkit::Control *argp2 ;
84944   bool result;
84945
84946   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
84947   argp2 = (Dali::Toolkit::Control *)jarg2;
84948   if (!argp2) {
84949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
84950     return 0;
84951   }
84952   arg2 = *argp2;
84953   arg3 = (Dali::KeyEvent *)jarg3;
84954   if (!arg3) {
84955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
84956     return 0;
84957   }
84958   {
84959     try {
84960       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);
84961     } catch (std::out_of_range& e) {
84962       {
84963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84964       };
84965     } catch (std::exception& e) {
84966       {
84967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84968       };
84969     } catch (...) {
84970       {
84971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84972       };
84973     }
84974   }
84975   jresult = result;
84976   return jresult;
84977 }
84978
84979
84980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
84981   void * jresult ;
84982   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
84983
84984   {
84985     try {
84986       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
84987     } catch (std::out_of_range& e) {
84988       {
84989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84990       };
84991     } catch (std::exception& e) {
84992       {
84993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84994       };
84995     } catch (...) {
84996       {
84997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84998       };
84999     }
85000   }
85001   jresult = (void *)result;
85002   return jresult;
85003 }
85004
85005
85006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
85007   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
85008
85009   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
85010   {
85011     try {
85012       delete arg1;
85013     } catch (std::out_of_range& e) {
85014       {
85015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85016       };
85017     } catch (std::exception& e) {
85018       {
85019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85020       };
85021     } catch (...) {
85022       {
85023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85024       };
85025     }
85026   }
85027 }
85028
85029
85030 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
85031   unsigned int jresult ;
85032   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85033   bool result;
85034
85035   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85036   {
85037     try {
85038       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
85039     } catch (std::out_of_range& e) {
85040       {
85041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85042       };
85043     } catch (std::exception& e) {
85044       {
85045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85046       };
85047     } catch (...) {
85048       {
85049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85050       };
85051     }
85052   }
85053   jresult = result;
85054   return jresult;
85055 }
85056
85057
85058 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
85059   unsigned long jresult ;
85060   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85061   std::size_t result;
85062
85063   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85064   {
85065     try {
85066       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
85067     } catch (std::out_of_range& e) {
85068       {
85069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85070       };
85071     } catch (std::exception& e) {
85072       {
85073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85074       };
85075     } catch (...) {
85076       {
85077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85078       };
85079     }
85080   }
85081   jresult = (unsigned long)result;
85082   return jresult;
85083 }
85084
85085
85086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
85087   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85088   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
85089
85090   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85091   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
85092   {
85093     try {
85094       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
85095     } catch (std::out_of_range& e) {
85096       {
85097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85098       };
85099     } catch (std::exception& e) {
85100       {
85101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85102       };
85103     } catch (...) {
85104       {
85105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85106       };
85107     }
85108   }
85109 }
85110
85111
85112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
85113   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85114   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
85115
85116   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85117   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
85118   {
85119     try {
85120       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
85121     } catch (std::out_of_range& e) {
85122       {
85123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85124       };
85125     } catch (std::exception& e) {
85126       {
85127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85128       };
85129     } catch (...) {
85130       {
85131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85132       };
85133     }
85134   }
85135 }
85136
85137
85138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
85139   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85140   Dali::Toolkit::Control arg2 ;
85141   Dali::Toolkit::Control *argp2 ;
85142
85143   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85144   argp2 = (Dali::Toolkit::Control *)jarg2;
85145   if (!argp2) {
85146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
85147     return ;
85148   }
85149   arg2 = *argp2;
85150   {
85151     try {
85152       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
85153     } catch (std::out_of_range& e) {
85154       {
85155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85156       };
85157     } catch (std::exception& e) {
85158       {
85159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85160       };
85161     } catch (...) {
85162       {
85163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85164       };
85165     }
85166   }
85167 }
85168
85169
85170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
85171   void * jresult ;
85172   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
85173
85174   {
85175     try {
85176       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
85177     } catch (std::out_of_range& e) {
85178       {
85179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85180       };
85181     } catch (std::exception& e) {
85182       {
85183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85184       };
85185     } catch (...) {
85186       {
85187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85188       };
85189     }
85190   }
85191   jresult = (void *)result;
85192   return jresult;
85193 }
85194
85195
85196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
85197   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85198
85199   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85200   {
85201     try {
85202       delete arg1;
85203     } catch (std::out_of_range& e) {
85204       {
85205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85206       };
85207     } catch (std::exception& e) {
85208       {
85209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85210       };
85211     } catch (...) {
85212       {
85213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85214       };
85215     }
85216   }
85217 }
85218
85219
85220 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
85221   unsigned int jresult ;
85222   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85223   bool result;
85224
85225   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85226   {
85227     try {
85228       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
85229     } catch (std::out_of_range& e) {
85230       {
85231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85232       };
85233     } catch (std::exception& e) {
85234       {
85235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85236       };
85237     } catch (...) {
85238       {
85239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85240       };
85241     }
85242   }
85243   jresult = result;
85244   return jresult;
85245 }
85246
85247
85248 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
85249   unsigned long jresult ;
85250   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85251   std::size_t result;
85252
85253   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85254   {
85255     try {
85256       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
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 = (unsigned long)result;
85272   return jresult;
85273 }
85274
85275
85276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
85277   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85278   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
85279
85280   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85281   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
85282   {
85283     try {
85284       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
85285     } catch (std::out_of_range& e) {
85286       {
85287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85288       };
85289     } catch (std::exception& e) {
85290       {
85291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85292       };
85293     } catch (...) {
85294       {
85295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85296       };
85297     }
85298   }
85299 }
85300
85301
85302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
85303   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85304   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
85305
85306   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85307   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
85308   {
85309     try {
85310       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
85311     } catch (std::out_of_range& e) {
85312       {
85313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85314       };
85315     } catch (std::exception& e) {
85316       {
85317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85318       };
85319     } catch (...) {
85320       {
85321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85322       };
85323     }
85324   }
85325 }
85326
85327
85328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
85329   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85330   Dali::Toolkit::VideoView *arg2 = 0 ;
85331
85332   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85333   arg2 = (Dali::Toolkit::VideoView *)jarg2;
85334   if (!arg2) {
85335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
85336     return ;
85337   }
85338   {
85339     try {
85340       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
85341     } catch (std::out_of_range& e) {
85342       {
85343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85344       };
85345     } catch (std::exception& e) {
85346       {
85347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85348       };
85349     } catch (...) {
85350       {
85351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85352       };
85353     }
85354   }
85355 }
85356
85357
85358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
85359   void * jresult ;
85360   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
85361
85362   {
85363     try {
85364       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
85365     } catch (std::out_of_range& e) {
85366       {
85367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85368       };
85369     } catch (std::exception& e) {
85370       {
85371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85372       };
85373     } catch (...) {
85374       {
85375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85376       };
85377     }
85378   }
85379   jresult = (void *)result;
85380   return jresult;
85381 }
85382
85383
85384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
85385   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85386
85387   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85388   {
85389     try {
85390       delete arg1;
85391     } catch (std::out_of_range& e) {
85392       {
85393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85394       };
85395     } catch (std::exception& e) {
85396       {
85397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85398       };
85399     } catch (...) {
85400       {
85401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85402       };
85403     }
85404   }
85405 }
85406
85407
85408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
85409   unsigned int jresult ;
85410   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85411   bool result;
85412
85413   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85414   {
85415     try {
85416       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
85417     } catch (std::out_of_range& e) {
85418       {
85419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85420       };
85421     } catch (std::exception& e) {
85422       {
85423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85424       };
85425     } catch (...) {
85426       {
85427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85428       };
85429     }
85430   }
85431   jresult = result;
85432   return jresult;
85433 }
85434
85435
85436 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
85437   unsigned long jresult ;
85438   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85439   std::size_t result;
85440
85441   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85442   {
85443     try {
85444       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
85445     } catch (std::out_of_range& e) {
85446       {
85447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85448       };
85449     } catch (std::exception& e) {
85450       {
85451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85452       };
85453     } catch (...) {
85454       {
85455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85456       };
85457     }
85458   }
85459   jresult = (unsigned long)result;
85460   return jresult;
85461 }
85462
85463
85464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
85465   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85466   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
85467
85468   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85469   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
85470   {
85471     try {
85472       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
85473     } catch (std::out_of_range& e) {
85474       {
85475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85476       };
85477     } catch (std::exception& e) {
85478       {
85479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85480       };
85481     } catch (...) {
85482       {
85483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85484       };
85485     }
85486   }
85487 }
85488
85489
85490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
85491   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85492   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
85493
85494   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85495   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
85496   {
85497     try {
85498       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
85499     } catch (std::out_of_range& e) {
85500       {
85501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85502       };
85503     } catch (std::exception& e) {
85504       {
85505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85506       };
85507     } catch (...) {
85508       {
85509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85510       };
85511     }
85512   }
85513 }
85514
85515
85516 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
85517   unsigned int jresult ;
85518   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85519   Dali::Toolkit::Slider arg2 ;
85520   float arg3 ;
85521   Dali::Toolkit::Slider *argp2 ;
85522   bool result;
85523
85524   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85525   argp2 = (Dali::Toolkit::Slider *)jarg2;
85526   if (!argp2) {
85527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
85528     return 0;
85529   }
85530   arg2 = *argp2;
85531   arg3 = (float)jarg3;
85532   {
85533     try {
85534       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
85535     } catch (std::out_of_range& e) {
85536       {
85537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85538       };
85539     } catch (std::exception& e) {
85540       {
85541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85542       };
85543     } catch (...) {
85544       {
85545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85546       };
85547     }
85548   }
85549   jresult = result;
85550   return jresult;
85551 }
85552
85553
85554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
85555   void * jresult ;
85556   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
85557
85558   {
85559     try {
85560       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
85561     } catch (std::out_of_range& e) {
85562       {
85563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85564       };
85565     } catch (std::exception& e) {
85566       {
85567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85568       };
85569     } catch (...) {
85570       {
85571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85572       };
85573     }
85574   }
85575   jresult = (void *)result;
85576   return jresult;
85577 }
85578
85579
85580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
85581   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85582
85583   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85584   {
85585     try {
85586       delete arg1;
85587     } catch (std::out_of_range& e) {
85588       {
85589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85590       };
85591     } catch (std::exception& e) {
85592       {
85593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85594       };
85595     } catch (...) {
85596       {
85597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85598       };
85599     }
85600   }
85601 }
85602
85603
85604 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
85605   unsigned int jresult ;
85606   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85607   bool result;
85608
85609   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85610   {
85611     try {
85612       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
85613     } catch (std::out_of_range& e) {
85614       {
85615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85616       };
85617     } catch (std::exception& e) {
85618       {
85619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85620       };
85621     } catch (...) {
85622       {
85623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85624       };
85625     }
85626   }
85627   jresult = result;
85628   return jresult;
85629 }
85630
85631
85632 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
85633   unsigned long jresult ;
85634   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85635   std::size_t result;
85636
85637   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85638   {
85639     try {
85640       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
85641     } catch (std::out_of_range& e) {
85642       {
85643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85644       };
85645     } catch (std::exception& e) {
85646       {
85647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85648       };
85649     } catch (...) {
85650       {
85651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85652       };
85653     }
85654   }
85655   jresult = (unsigned long)result;
85656   return jresult;
85657 }
85658
85659
85660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
85661   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85662   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
85663
85664   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85665   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
85666   {
85667     try {
85668       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
85669     } catch (std::out_of_range& e) {
85670       {
85671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85672       };
85673     } catch (std::exception& e) {
85674       {
85675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85676       };
85677     } catch (...) {
85678       {
85679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85680       };
85681     }
85682   }
85683 }
85684
85685
85686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
85687   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85688   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
85689
85690   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85691   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
85692   {
85693     try {
85694       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
85695     } catch (std::out_of_range& e) {
85696       {
85697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85698       };
85699     } catch (std::exception& e) {
85700       {
85701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85702       };
85703     } catch (...) {
85704       {
85705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85706       };
85707     }
85708   }
85709 }
85710
85711
85712 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
85713   unsigned int jresult ;
85714   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85715   Dali::Toolkit::Slider arg2 ;
85716   int arg3 ;
85717   Dali::Toolkit::Slider *argp2 ;
85718   bool result;
85719
85720   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85721   argp2 = (Dali::Toolkit::Slider *)jarg2;
85722   if (!argp2) {
85723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
85724     return 0;
85725   }
85726   arg2 = *argp2;
85727   arg3 = (int)jarg3;
85728   {
85729     try {
85730       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
85731     } catch (std::out_of_range& e) {
85732       {
85733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85734       };
85735     } catch (std::exception& e) {
85736       {
85737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85738       };
85739     } catch (...) {
85740       {
85741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85742       };
85743     }
85744   }
85745   jresult = result;
85746   return jresult;
85747 }
85748
85749
85750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
85751   void * jresult ;
85752   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
85753
85754   {
85755     try {
85756       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
85757     } catch (std::out_of_range& e) {
85758       {
85759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85760       };
85761     } catch (std::exception& e) {
85762       {
85763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85764       };
85765     } catch (...) {
85766       {
85767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85768       };
85769     }
85770   }
85771   jresult = (void *)result;
85772   return jresult;
85773 }
85774
85775
85776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
85777   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85778
85779   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85780   {
85781     try {
85782       delete arg1;
85783     } catch (std::out_of_range& e) {
85784       {
85785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85786       };
85787     } catch (std::exception& e) {
85788       {
85789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85790       };
85791     } catch (...) {
85792       {
85793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85794       };
85795     }
85796   }
85797 }
85798
85799
85800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
85801   void * jresult ;
85802   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
85803
85804   {
85805     try {
85806       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
85807     } catch (std::out_of_range& e) {
85808       {
85809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85810       };
85811     } catch (std::exception& e) {
85812       {
85813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85814       };
85815     } catch (...) {
85816       {
85817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85818       };
85819     }
85820   }
85821   jresult = (void *)result;
85822   return jresult;
85823 }
85824
85825
85826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
85827   void * jresult ;
85828   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
85829   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
85830
85831   arg1 = (Dali::Toolkit::Ruler *)jarg1;
85832   {
85833     try {
85834       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
85835     } catch (std::out_of_range& e) {
85836       {
85837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85838       };
85839     } catch (std::exception& e) {
85840       {
85841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85842       };
85843     } catch (...) {
85844       {
85845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85846       };
85847     }
85848   }
85849   jresult = (void *)result;
85850   return jresult;
85851 }
85852
85853
85854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
85855   void * jresult ;
85856   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
85857   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
85858
85859   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
85860   if (!arg1) {
85861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
85862     return 0;
85863   }
85864   {
85865     try {
85866       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
85867     } catch (std::out_of_range& e) {
85868       {
85869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85870       };
85871     } catch (std::exception& e) {
85872       {
85873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85874       };
85875     } catch (...) {
85876       {
85877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85878       };
85879     }
85880   }
85881   jresult = (void *)result;
85882   return jresult;
85883 }
85884
85885
85886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
85887   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
85888
85889   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
85890   {
85891     try {
85892       delete arg1;
85893     } catch (std::out_of_range& e) {
85894       {
85895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85896       };
85897     } catch (std::exception& e) {
85898       {
85899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85900       };
85901     } catch (...) {
85902       {
85903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85904       };
85905     }
85906   }
85907 }
85908
85909
85910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
85911   void * jresult ;
85912   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
85913   Dali::Toolkit::Ruler *result = 0 ;
85914
85915   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
85916   {
85917     try {
85918       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
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 = (void *)result;
85934   return jresult;
85935 }
85936
85937
85938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
85939   void * jresult ;
85940   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
85941   Dali::Toolkit::Ruler *result = 0 ;
85942
85943   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
85944   {
85945     try {
85946       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
85947     } catch (std::out_of_range& e) {
85948       {
85949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85950       };
85951     } catch (std::exception& e) {
85952       {
85953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85954       };
85955     } catch (...) {
85956       {
85957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85958       };
85959     }
85960   }
85961   jresult = (void *)result;
85962   return jresult;
85963 }
85964
85965
85966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
85967   void * jresult ;
85968   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
85969   Dali::Toolkit::Ruler *result = 0 ;
85970
85971   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
85972   {
85973     try {
85974       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
85975     } catch (std::out_of_range& e) {
85976       {
85977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85978       };
85979     } catch (std::exception& e) {
85980       {
85981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85982       };
85983     } catch (...) {
85984       {
85985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85986       };
85987     }
85988   }
85989   jresult = (void *)result;
85990   return jresult;
85991 }
85992
85993
85994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
85995   void * jresult ;
85996   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
85997   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
85998   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
85999
86000   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86001   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
86002   if (!arg2) {
86003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
86004     return 0;
86005   }
86006   {
86007     try {
86008       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
86009     } catch (std::out_of_range& e) {
86010       {
86011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86012       };
86013     } catch (std::exception& e) {
86014       {
86015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86016       };
86017     } catch (...) {
86018       {
86019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86020       };
86021     }
86022   }
86023   jresult = (void *)result;
86024   return jresult;
86025 }
86026
86027
86028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
86029   void * jresult ;
86030   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86031   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
86032   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
86033
86034   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86035   arg2 = (Dali::Toolkit::Ruler *)jarg2;
86036   {
86037     try {
86038       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
86039     } catch (std::out_of_range& e) {
86040       {
86041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86042       };
86043     } catch (std::exception& e) {
86044       {
86045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86046       };
86047     } catch (...) {
86048       {
86049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86050       };
86051     }
86052   }
86053   jresult = (void *)result;
86054   return jresult;
86055 }
86056
86057
86058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
86059   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86060
86061   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86062   {
86063     try {
86064       (arg1)->Reset();
86065     } catch (std::out_of_range& e) {
86066       {
86067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86068       };
86069     } catch (std::exception& e) {
86070       {
86071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86072       };
86073     } catch (...) {
86074       {
86075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86076       };
86077     }
86078   }
86079 }
86080
86081
86082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
86083   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86084   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
86085
86086   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86087   arg2 = (Dali::Toolkit::Ruler *)jarg2;
86088   {
86089     try {
86090       (arg1)->Reset(arg2);
86091     } catch (std::out_of_range& e) {
86092       {
86093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86094       };
86095     } catch (std::exception& e) {
86096       {
86097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86098       };
86099     } catch (...) {
86100       {
86101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86102       };
86103     }
86104   }
86105 }
86106
86107
86108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
86109   void * jresult ;
86110   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86111   Dali::Toolkit::Ruler *result = 0 ;
86112
86113   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86114   {
86115     try {
86116       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
86117     } catch (std::out_of_range& e) {
86118       {
86119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86120       };
86121     } catch (std::exception& e) {
86122       {
86123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86124       };
86125     } catch (...) {
86126       {
86127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86128       };
86129     }
86130   }
86131   jresult = (void *)result;
86132   return jresult;
86133 }
86134
86135
86136 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
86137   float jresult ;
86138   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86139   float arg2 ;
86140   float arg3 ;
86141   float result;
86142
86143   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86144   arg2 = (float)jarg2;
86145   arg3 = (float)jarg3;
86146   {
86147     try {
86148       result = (float)(*arg1)->Snap(arg2,arg3);
86149     } catch (std::out_of_range& e) {
86150       {
86151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86152       };
86153     } catch (std::exception& e) {
86154       {
86155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86156       };
86157     } catch (...) {
86158       {
86159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86160       };
86161     }
86162   }
86163   jresult = result;
86164   return jresult;
86165 }
86166
86167
86168 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
86169   float jresult ;
86170   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86171   float arg2 ;
86172   float result;
86173
86174   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86175   arg2 = (float)jarg2;
86176   {
86177     try {
86178       result = (float)(*arg1)->Snap(arg2);
86179     } catch (std::out_of_range& e) {
86180       {
86181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86182       };
86183     } catch (std::exception& e) {
86184       {
86185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86186       };
86187     } catch (...) {
86188       {
86189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86190       };
86191     }
86192   }
86193   jresult = result;
86194   return jresult;
86195 }
86196
86197
86198 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
86199   float jresult ;
86200   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86201   unsigned int arg2 ;
86202   unsigned int *arg3 = 0 ;
86203   bool arg4 ;
86204   float result;
86205
86206   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86207   arg2 = (unsigned int)jarg2;
86208   arg3 = (unsigned int *)jarg3;
86209   arg4 = jarg4 ? true : false;
86210   {
86211     try {
86212       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
86213     } catch (std::out_of_range& e) {
86214       {
86215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86216       };
86217     } catch (std::exception& e) {
86218       {
86219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86220       };
86221     } catch (...) {
86222       {
86223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86224       };
86225     }
86226   }
86227   jresult = result;
86228   return jresult;
86229 }
86230
86231
86232 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
86233   unsigned int jresult ;
86234   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86235   float arg2 ;
86236   bool arg3 ;
86237   unsigned int result;
86238
86239   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86240   arg2 = (float)jarg2;
86241   arg3 = jarg3 ? true : false;
86242   {
86243     try {
86244       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
86245     } catch (std::out_of_range& e) {
86246       {
86247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86248       };
86249     } catch (std::exception& e) {
86250       {
86251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86252       };
86253     } catch (...) {
86254       {
86255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86256       };
86257     }
86258   }
86259   jresult = result;
86260   return jresult;
86261 }
86262
86263
86264 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
86265   unsigned int jresult ;
86266   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86267   unsigned int result;
86268
86269   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86270   {
86271     try {
86272       result = (unsigned int)(*arg1)->GetTotalPages();
86273     } catch (std::out_of_range& e) {
86274       {
86275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86276       };
86277     } catch (std::exception& e) {
86278       {
86279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86280       };
86281     } catch (...) {
86282       {
86283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86284       };
86285     }
86286   }
86287   jresult = result;
86288   return jresult;
86289 }
86290
86291
86292 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
86293   int jresult ;
86294   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86295   Dali::Toolkit::Ruler::RulerType result;
86296
86297   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86298   {
86299     try {
86300       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
86301     } catch (std::out_of_range& e) {
86302       {
86303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86304       };
86305     } catch (std::exception& e) {
86306       {
86307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86308       };
86309     } catch (...) {
86310       {
86311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86312       };
86313     }
86314   }
86315   jresult = (int)result;
86316   return jresult;
86317 }
86318
86319
86320 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
86321   unsigned int jresult ;
86322   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86323   bool result;
86324
86325   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86326   {
86327     try {
86328       result = (bool)(*arg1)->IsEnabled();
86329     } catch (std::out_of_range& e) {
86330       {
86331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86332       };
86333     } catch (std::exception& e) {
86334       {
86335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86336       };
86337     } catch (...) {
86338       {
86339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86340       };
86341     }
86342   }
86343   jresult = result;
86344   return jresult;
86345 }
86346
86347
86348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
86349   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86350
86351   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86352   {
86353     try {
86354       (*arg1)->Enable();
86355     } catch (std::out_of_range& e) {
86356       {
86357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86358       };
86359     } catch (std::exception& e) {
86360       {
86361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86362       };
86363     } catch (...) {
86364       {
86365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86366       };
86367     }
86368   }
86369 }
86370
86371
86372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
86373   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86374
86375   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86376   {
86377     try {
86378       (*arg1)->Disable();
86379     } catch (std::out_of_range& e) {
86380       {
86381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86382       };
86383     } catch (std::exception& e) {
86384       {
86385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86386       };
86387     } catch (...) {
86388       {
86389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86390       };
86391     }
86392   }
86393 }
86394
86395
86396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
86397   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86398   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
86399   Dali::Toolkit::RulerDomain *argp2 ;
86400
86401   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86402   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
86403   if (!argp2) {
86404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
86405     return ;
86406   }
86407   arg2 = *argp2;
86408   {
86409     try {
86410       (*arg1)->SetDomain(arg2);
86411     } catch (std::out_of_range& e) {
86412       {
86413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86414       };
86415     } catch (std::exception& e) {
86416       {
86417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86418       };
86419     } catch (...) {
86420       {
86421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86422       };
86423     }
86424   }
86425 }
86426
86427
86428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
86429   void * jresult ;
86430   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86431   Dali::Toolkit::RulerDomain *result = 0 ;
86432
86433   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86434   {
86435     try {
86436       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
86437     } catch (std::out_of_range& e) {
86438       {
86439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86440       };
86441     } catch (std::exception& e) {
86442       {
86443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86444       };
86445     } catch (...) {
86446       {
86447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86448       };
86449     }
86450   }
86451   jresult = (void *)result;
86452   return jresult;
86453 }
86454
86455
86456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
86457   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86458
86459   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86460   {
86461     try {
86462       (*arg1)->DisableDomain();
86463     } catch (std::out_of_range& e) {
86464       {
86465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86466       };
86467     } catch (std::exception& e) {
86468       {
86469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86470       };
86471     } catch (...) {
86472       {
86473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86474       };
86475     }
86476   }
86477 }
86478
86479
86480 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
86481   float jresult ;
86482   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86483   float arg2 ;
86484   float arg3 ;
86485   float arg4 ;
86486   float result;
86487
86488   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86489   arg2 = (float)jarg2;
86490   arg3 = (float)jarg3;
86491   arg4 = (float)jarg4;
86492   {
86493     try {
86494       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
86495     } catch (std::out_of_range& e) {
86496       {
86497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86498       };
86499     } catch (std::exception& e) {
86500       {
86501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86502       };
86503     } catch (...) {
86504       {
86505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86506       };
86507     }
86508   }
86509   jresult = result;
86510   return jresult;
86511 }
86512
86513
86514 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
86515   float jresult ;
86516   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86517   float arg2 ;
86518   float arg3 ;
86519   float result;
86520
86521   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86522   arg2 = (float)jarg2;
86523   arg3 = (float)jarg3;
86524   {
86525     try {
86526       result = (float)(*arg1)->Clamp(arg2,arg3);
86527     } catch (std::out_of_range& e) {
86528       {
86529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86530       };
86531     } catch (std::exception& e) {
86532       {
86533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86534       };
86535     } catch (...) {
86536       {
86537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86538       };
86539     }
86540   }
86541   jresult = result;
86542   return jresult;
86543 }
86544
86545
86546 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
86547   float jresult ;
86548   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86549   float arg2 ;
86550   float result;
86551
86552   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86553   arg2 = (float)jarg2;
86554   {
86555     try {
86556       result = (float)(*arg1)->Clamp(arg2);
86557     } catch (std::out_of_range& e) {
86558       {
86559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86560       };
86561     } catch (std::exception& e) {
86562       {
86563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86564       };
86565     } catch (...) {
86566       {
86567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86568       };
86569     }
86570   }
86571   jresult = result;
86572   return jresult;
86573 }
86574
86575
86576 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
86577   float jresult ;
86578   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86579   float arg2 ;
86580   float arg3 ;
86581   float arg4 ;
86582   Dali::Toolkit::ClampState *arg5 = 0 ;
86583   float result;
86584
86585   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86586   arg2 = (float)jarg2;
86587   arg3 = (float)jarg3;
86588   arg4 = (float)jarg4;
86589   arg5 = (Dali::Toolkit::ClampState *)jarg5;
86590   if (!arg5) {
86591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
86592     return 0;
86593   }
86594   {
86595     try {
86596       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
86597     } catch (std::out_of_range& e) {
86598       {
86599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86600       };
86601     } catch (std::exception& e) {
86602       {
86603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86604       };
86605     } catch (...) {
86606       {
86607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86608       };
86609     }
86610   }
86611   jresult = result;
86612   return jresult;
86613 }
86614
86615
86616 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
86617   float jresult ;
86618   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86619   float arg2 ;
86620   float arg3 ;
86621   float arg4 ;
86622   float arg5 ;
86623   float result;
86624
86625   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86626   arg2 = (float)jarg2;
86627   arg3 = (float)jarg3;
86628   arg4 = (float)jarg4;
86629   arg5 = (float)jarg5;
86630   {
86631     try {
86632       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
86633     } catch (std::out_of_range& e) {
86634       {
86635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86636       };
86637     } catch (std::exception& e) {
86638       {
86639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86640       };
86641     } catch (...) {
86642       {
86643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86644       };
86645     }
86646   }
86647   jresult = result;
86648   return jresult;
86649 }
86650
86651
86652 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
86653   float jresult ;
86654   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86655   float arg2 ;
86656   float arg3 ;
86657   float arg4 ;
86658   float result;
86659
86660   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86661   arg2 = (float)jarg2;
86662   arg3 = (float)jarg3;
86663   arg4 = (float)jarg4;
86664   {
86665     try {
86666       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
86667     } catch (std::out_of_range& e) {
86668       {
86669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86670       };
86671     } catch (std::exception& e) {
86672       {
86673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86674       };
86675     } catch (...) {
86676       {
86677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86678       };
86679     }
86680   }
86681   jresult = result;
86682   return jresult;
86683 }
86684
86685
86686 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
86687   float jresult ;
86688   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86689   float arg2 ;
86690   float arg3 ;
86691   float result;
86692
86693   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86694   arg2 = (float)jarg2;
86695   arg3 = (float)jarg3;
86696   {
86697     try {
86698       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
86699     } catch (std::out_of_range& e) {
86700       {
86701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86702       };
86703     } catch (std::exception& e) {
86704       {
86705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86706       };
86707     } catch (...) {
86708       {
86709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86710       };
86711     }
86712   }
86713   jresult = result;
86714   return jresult;
86715 }
86716
86717
86718 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
86719   float jresult ;
86720   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86721   float arg2 ;
86722   float result;
86723
86724   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86725   arg2 = (float)jarg2;
86726   {
86727     try {
86728       result = (float)(*arg1)->SnapAndClamp(arg2);
86729     } catch (std::out_of_range& e) {
86730       {
86731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86732       };
86733     } catch (std::exception& e) {
86734       {
86735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86736       };
86737     } catch (...) {
86738       {
86739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86740       };
86741     }
86742   }
86743   jresult = result;
86744   return jresult;
86745 }
86746
86747
86748 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
86749   float jresult ;
86750   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86751   float arg2 ;
86752   float arg3 ;
86753   float arg4 ;
86754   float arg5 ;
86755   Dali::Toolkit::ClampState *arg6 = 0 ;
86756   float result;
86757
86758   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86759   arg2 = (float)jarg2;
86760   arg3 = (float)jarg3;
86761   arg4 = (float)jarg4;
86762   arg5 = (float)jarg5;
86763   arg6 = (Dali::Toolkit::ClampState *)jarg6;
86764   if (!arg6) {
86765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
86766     return 0;
86767   }
86768   {
86769     try {
86770       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
86771     } catch (std::out_of_range& e) {
86772       {
86773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86774       };
86775     } catch (std::exception& e) {
86776       {
86777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86778       };
86779     } catch (...) {
86780       {
86781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86782       };
86783     }
86784   }
86785   jresult = result;
86786   return jresult;
86787 }
86788
86789
86790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
86791   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86792
86793   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86794   {
86795     try {
86796       (*arg1)->Reference();
86797     } catch (std::out_of_range& e) {
86798       {
86799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86800       };
86801     } catch (std::exception& e) {
86802       {
86803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86804       };
86805     } catch (...) {
86806       {
86807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86808       };
86809     }
86810   }
86811 }
86812
86813
86814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
86815   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86816
86817   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86818   {
86819     try {
86820       (*arg1)->Unreference();
86821     } catch (std::out_of_range& e) {
86822       {
86823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86824       };
86825     } catch (std::exception& e) {
86826       {
86827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86828       };
86829     } catch (...) {
86830       {
86831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86832       };
86833     }
86834   }
86835 }
86836
86837
86838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
86839   int jresult ;
86840   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86841   int result;
86842
86843   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86844   {
86845     try {
86846       result = (int)(*arg1)->ReferenceCount();
86847     } catch (std::out_of_range& e) {
86848       {
86849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86850       };
86851     } catch (std::exception& e) {
86852       {
86853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86854       };
86855     } catch (...) {
86856       {
86857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86858       };
86859     }
86860   }
86861   jresult = result;
86862   return jresult;
86863 }
86864
86865
86866 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
86867   unsigned int jresult ;
86868   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
86869   bool result;
86870
86871   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
86872   {
86873     try {
86874       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
86875     } catch (std::out_of_range& e) {
86876       {
86877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86878       };
86879     } catch (std::exception& e) {
86880       {
86881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86882       };
86883     } catch (...) {
86884       {
86885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86886       };
86887     }
86888   }
86889   jresult = result;
86890   return jresult;
86891 }
86892
86893
86894 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
86895   unsigned long jresult ;
86896   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
86897   std::size_t result;
86898
86899   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
86900   {
86901     try {
86902       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
86903     } catch (std::out_of_range& e) {
86904       {
86905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86906       };
86907     } catch (std::exception& e) {
86908       {
86909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86910       };
86911     } catch (...) {
86912       {
86913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86914       };
86915     }
86916   }
86917   jresult = (unsigned long)result;
86918   return jresult;
86919 }
86920
86921
86922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
86923   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
86924   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
86925
86926   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
86927   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
86928   {
86929     try {
86930       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
86931     } catch (std::out_of_range& e) {
86932       {
86933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86934       };
86935     } catch (std::exception& e) {
86936       {
86937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86938       };
86939     } catch (...) {
86940       {
86941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86942       };
86943     }
86944   }
86945 }
86946
86947
86948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
86949   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
86950   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
86951
86952   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
86953   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
86954   {
86955     try {
86956       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
86957     } catch (std::out_of_range& e) {
86958       {
86959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86960       };
86961     } catch (std::exception& e) {
86962       {
86963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86964       };
86965     } catch (...) {
86966       {
86967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86968       };
86969     }
86970   }
86971 }
86972
86973
86974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
86975   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
86976   Dali::Toolkit::Control arg2 ;
86977   Dali::Toolkit::Control *argp2 ;
86978
86979   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
86980   argp2 = (Dali::Toolkit::Control *)jarg2;
86981   if (!argp2) {
86982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
86983     return ;
86984   }
86985   arg2 = *argp2;
86986   {
86987     try {
86988       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
86989     } catch (std::out_of_range& e) {
86990       {
86991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86992       };
86993     } catch (std::exception& e) {
86994       {
86995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86996       };
86997     } catch (...) {
86998       {
86999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87000       };
87001     }
87002   }
87003 }
87004
87005
87006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
87007   void * jresult ;
87008   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
87009
87010   {
87011     try {
87012       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
87013     } catch (std::out_of_range& e) {
87014       {
87015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87016       };
87017     } catch (std::exception& e) {
87018       {
87019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87020       };
87021     } catch (...) {
87022       {
87023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87024       };
87025     }
87026   }
87027   jresult = (void *)result;
87028   return jresult;
87029 }
87030
87031
87032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
87033   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
87034
87035   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
87036   {
87037     try {
87038       delete arg1;
87039     } catch (std::out_of_range& e) {
87040       {
87041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87042       };
87043     } catch (std::exception& e) {
87044       {
87045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87046       };
87047     } catch (...) {
87048       {
87049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87050       };
87051     }
87052   }
87053 }
87054
87055 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
87056   Dali::RefObject *result = NULL;
87057
87058   if (arg1)
87059   {
87060     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
87061   }
87062   return result;
87063 }
87064
87065 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
87066     return (Dali::RefObject *)jarg1;
87067 }
87068
87069 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
87070     return (Dali::SignalObserver *)jarg1;
87071 }
87072
87073 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
87074     return (Dali::ConnectionTrackerInterface *)jarg1;
87075 }
87076
87077 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
87078     return (Dali::BaseHandle *)jarg1;
87079 }
87080
87081 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
87082     return (Dali::BaseHandle *)jarg1;
87083 }
87084
87085 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
87086     return (Dali::BaseHandle *)jarg1;
87087 }
87088
87089 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
87090     return (Dali::BaseHandle *)jarg1;
87091 }
87092
87093 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
87094     return (Dali::BaseHandle *)jarg1;
87095 }
87096
87097 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
87098     return (Dali::BaseHandle *)jarg1;
87099 }
87100
87101 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
87102     return (Dali::BaseHandle *)jarg1;
87103 }
87104
87105 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
87106     return (Dali::BaseHandle *)jarg1;
87107 }
87108
87109 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
87110     return (Dali::BaseHandle *)jarg1;
87111 }
87112
87113 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
87114     return (Dali::BaseHandle *)jarg1;
87115 }
87116
87117 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
87118     return (Dali::BaseHandle *)jarg1;
87119 }
87120
87121 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
87122     return (Dali::BaseHandle *)jarg1;
87123 }
87124
87125 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
87126     return (Dali::BaseHandle *)jarg1;
87127 }
87128
87129 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
87130     return (Dali::Handle *)jarg1;
87131 }
87132
87133 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
87134     return (Dali::Handle *)jarg1;
87135 }
87136
87137 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
87138     return (Dali::BaseHandle *)jarg1;
87139 }
87140
87141 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
87142     return (Dali::BaseHandle *)jarg1;
87143 }
87144
87145 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
87146     return (Dali::Handle *)jarg1;
87147 }
87148
87149 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
87150     return (Dali::BaseHandle *)jarg1;
87151 }
87152
87153 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
87154     return (Dali::Handle *)jarg1;
87155 }
87156
87157 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
87158     return (Dali::GestureDetector *)jarg1;
87159 }
87160
87161 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
87162     return (Dali::Gesture *)jarg1;
87163 }
87164
87165 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
87166     return (Dali::Handle *)jarg1;
87167 }
87168
87169 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
87170     return (Dali::Actor *)jarg1;
87171 }
87172
87173 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
87174     return (Dali::BaseHandle *)jarg1;
87175 }
87176
87177 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
87178     return (Dali::RefObject *)jarg1;
87179 }
87180
87181 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
87182     return (Dali::Actor *)jarg1;
87183 }
87184
87185 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
87186     return (Dali::GestureDetector *)jarg1;
87187 }
87188
87189 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
87190     return (Dali::Gesture *)jarg1;
87191 }
87192
87193 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
87194     return (Dali::GestureDetector *)jarg1;
87195 }
87196
87197 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
87198     return (Dali::Gesture *)jarg1;
87199 }
87200
87201 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
87202     return (Dali::GestureDetector *)jarg1;
87203 }
87204
87205 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
87206     return (Dali::Gesture *)jarg1;
87207 }
87208
87209 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
87210     return (Dali::BaseHandle *)jarg1;
87211 }
87212
87213 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
87214     return (Dali::Handle *)jarg1;
87215 }
87216
87217 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
87218     return (Dali::Handle *)jarg1;
87219 }
87220
87221 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
87222     return (Dali::Handle *)jarg1;
87223 }
87224
87225 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
87226     return (Dali::Image *)jarg1;
87227 }
87228
87229 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
87230     return (Dali::Image *)jarg1;
87231 }
87232
87233 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
87234     return (Dali::Image *)jarg1;
87235 }
87236
87237 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
87238     return (Dali::RefObject *)jarg1;
87239 }
87240
87241 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
87242     return (Dali::Image *)jarg1;
87243 }
87244
87245 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
87246     return (Dali::Image *)jarg1;
87247 }
87248
87249 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
87250     return (Dali::ResourceImage *)jarg1;
87251 }
87252
87253 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
87254     return (Dali::Actor *)jarg1;
87255 }
87256
87257 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
87258     return (Dali::BaseHandle *)jarg1;
87259 }
87260
87261 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
87262     return (Dali::BaseHandle *)jarg1;
87263 }
87264
87265
87266 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
87267     return (Dali::BaseHandle *)jarg1;
87268 }
87269
87270 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
87271     return (Dali::BaseHandle *)jarg1;
87272 }
87273
87274 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
87275     return (Dali::CustomActorImpl *)jarg1;
87276 }
87277
87278 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
87279     return (Dali::CustomActor *)jarg1;
87280 }
87281
87282 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
87283     return (Dali::BaseHandle *)jarg1;
87284 }
87285
87286 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
87287     return (Dali::Toolkit::Control *)jarg1;
87288 }
87289
87290 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
87291     return (Dali::Toolkit::Control *)jarg1;
87292 }
87293
87294 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
87295     return (Dali::Toolkit::Button *)jarg1;
87296 }
87297
87298 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
87299     return (Dali::Toolkit::Button *)jarg1;
87300 }
87301
87302 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
87303     return (Dali::Toolkit::Button *)jarg1;
87304 }
87305
87306 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
87307     return (Dali::Toolkit::Control *)jarg1;
87308 }
87309
87310 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
87311     return (Dali::Toolkit::Control *)jarg1;
87312 }
87313
87314 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
87315     return (Dali::Toolkit::Control *)jarg1;
87316 }
87317
87318 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
87319     return (Dali::Toolkit::Control *)jarg1;
87320 }
87321
87322 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
87323     return (Dali::Toolkit::Control *)jarg1;
87324 }
87325
87326 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
87327     return (Dali::RefObject *)jarg1;
87328 }
87329
87330 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
87331     return (Dali::Toolkit::Scrollable *)jarg1;
87332 }
87333
87334 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
87335     return (Dali::BaseHandle *)jarg1;
87336 }
87337
87338 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
87339     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
87340 }
87341
87342 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
87343     return (Dali::RefObject *)jarg1;
87344 }
87345
87346 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
87347     return (Dali::Toolkit::Ruler *)jarg1;
87348 }
87349
87350 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
87351     return (Dali::Toolkit::Ruler *)jarg1;
87352 }
87353
87354 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
87355     return (Dali::Toolkit::Scrollable *)jarg1;
87356 }
87357
87358 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
87359     return (Dali::Toolkit::Control *)jarg1;
87360 }
87361
87362
87363 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
87364     return (Dali::Toolkit::Control *)jarg1;
87365 }
87366
87367 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
87368     return (Dali::BaseHandle *)jarg1;
87369 }
87370
87371 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
87372     return (Dali::BaseHandle *)jarg1;
87373 }
87374
87375 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
87376     return (Dali::Toolkit::Control *)jarg1;
87377 }
87378
87379 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
87380     return (Dali::Toolkit::Control *)jarg1;
87381 }
87382
87383 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
87384     return (Dali::Toolkit::Control *)jarg1;
87385 }
87386
87387 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
87388     return (Dali::Toolkit::Control *)jarg1;
87389 }
87390
87391 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
87392     return (Dali::Toolkit::Control *)jarg1;
87393 }
87394
87395 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
87396     return (Dali::Toolkit::Control *)jarg1;
87397 }
87398
87399 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
87400     return (Dali::Toolkit::PageTurnView *)jarg1;
87401 }
87402
87403 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
87404     return (Dali::Toolkit::PageTurnView *)jarg1;
87405 }
87406
87407 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
87408     return (Dali::Toolkit::Button *)jarg1;
87409 }
87410
87411 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
87412     return (Dali::BaseHandle *)jarg1;
87413 }
87414
87415 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
87416     return (Dali::BaseHandle *)jarg1;
87417 }
87418
87419 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
87420     return (Dali::BaseHandle *)jarg1;
87421 }
87422
87423
87424 #ifdef __cplusplus
87425 }
87426 #endif